تشغيل أي مهارة في Manus بنقرة واحدة

use-case-c

النجوم٠

التفرعات٠

آخر تحديث٢٧ يونيو ٢٠٢٦ في ١٨:٠٩

The Squeeze Loop instance for Use Case C — an HTTP API where the document plane (OpenAPI contract) and the runtime plane (live server) are forced into exact lockstep, on terrain C (split planes). The dominant failure is blending — a clean schema masking broken runtime behaviour (id leaks, tracebacks, missing auth), or a clean runtime escaping stale documentation. The exerciser RUNS the live server over HTTP but is physically denied the server source and the published schema (the load-bearing "run, don't read" channel). Use when working on src/C — the API governance policy, the canonical OpenAPI contract, the schema linter, the live server, the conformance test matrix, the legacy route-signature regression oracle, or the no-blend cross-check. Trigger phrasings: "use case C", "instance C", "split planes", "document vs runtime plane", "no-blend", "run don't read", "OpenAPI conformance squeeze", "id leak / missing auth on an untested route".

التثبيت

التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.

تشغيل في Manus

المصدر

canonical

canonical/squeeze-loop

فتح مستودع GitHub عرض مستودعات المنشئ

تنزيل

تشغيل في Manus

المهن ذات الصلةSOC

استنادا إلى تصنيف SOC المهني

مطوّرو البرمجياتمهن الحاسوب والرياضيات·SOC 15-1252

SKILL.md

readonly

name

use-case-c

description

Use Case C — the split-planes API squeeze loop

Use Case C is a base squeeze loop (instance-c, terrain C): an API whose document plane (the published OpenAPI schema) and runtime plane (the live HTTP server) are forced into exact lockstep so neither can mask the other. Its SL-1.0 self-description is src/C/instance-c.sl.json; the companion write-up is src/C/docs/use-case-c.md.

The dominant failure it guards

Coherent-and-wrong here = blending — one plane's weak check standing in for the other's strong claim: a clean schema masking broken runtime behaviour (id leaks, tracebacks, missing auth on an untested route), or a clean runtime escaping stale documentation.

Terrain C — split planes

Correctness divides across two planes, each with its own authority:

Runtime plane — the API governance policy API_POLICY_081 (CLAUSE_1 auth, CLAUSE_2 uuid-only ids, CLAUSE_3 clean errors).
Document plane — the canonical OpenAPI contract base_schema.json (0444), read independently by both bands.

The soundness load rests on a no-blend cross-check: each plane is verified separately and the planes must agree.

The bounds

Upper bound U — both plane authorities (governance policy + canonical contract), which the sentinel refuses to let blend.
Lower bound L — the schema linter (document plane), the frozen app-state DB, the legacy route-signature regression oracle (ty0_baseline), and — for the exerciser — the live server observed over HTTP.

The cast (three actors) and the run-vs-read channel

Actor	Builds	`U`	`L`	Must not see
Gate sentinel / no-blend referee (coordinator)	the gate sequence + the `.sl.json`	both plane authorities	linter + runtime HTTP + frozen DB + legacy-signature regression + both bands	—
API implementer	the HTTP server + its published OpenAPI schema	policy + canonical contract	the frozen DB it serves; the linter its schema must pass	the conformance matrix
Conformance exerciser	the conformance test matrix	policy + canonical contract, read independently	what the live server returns when RUN over HTTP	the server source + the implementer's `openapi.json`

The load-bearing subtlety: the implementer produces the running server (runtime_oracle), but the exerciser runs it over HTTP as its lower bound — it never reads the source. A judge may run an oracle over an artifact it is barriered from; it may never read that artifact. That run-vs-read distinction is what keeps the barrier physical rather than honorary.

The gates

Gate A / isolation. The exerciser has zero import/path linkage to the server source.
Gate B (runtime). Status codes, exact response keys, no forbidden patterns (no id leaks, no tracebacks) on every tested route; plus the document-plane route cross-check.
Gate C (coverage / no-blend). Every clause maps to a passing check on its plane, seeded coherent-and-wrong negatives fire, and a clean check on one plane never stands in for the other; the legacy ty0 signature hash re-verifies (no regression).

Disjointness

The implementer is bound by both plane authorities but reads only the frozen DB and the linter below; the exerciser is bound by the same authorities but its lower bound is the running server observed over HTTP — it runs the implementation without ever reading its source. The sentinel certifies only when both planes pass separately and agree, so neither plane's check can mask the other. Catchability: an implementer blend (clean schema/happy path hiding an id leak or missing auth) is caught by the exerciser's runtime assertions + route cross-check; a weak happy-path matrix is caught by the sentinel (Gate C coverage + seeded negatives).

python config/skills/sl-internal/scripts/sl_disjointness_check.py src/C/instance-c.sl.json

(0 FAIL / 8 checks.)

المزيد من هذا المستودع

نفس المستودع

sl-auditor

canonical/squeeze-loop

Audits an existing Squeeze Loop (SL) for soundness — checking whether a target loop is truly compliant (pairwise-disjoint authority pairs, physically barriered contexts, gate-defined "done", a genuine executable lower bound, and demonstrated catching of coherent-and-wrong) or is quietly collapsing into a rubber stamp. It applies the squeeze's own discipline to the loop under audit: it maps the actual (upper, lower) authority pairs and hunts for an actor certifying its own work; probes whether each context barrier is physical or merely honorary; confirms an executable oracle disjoint from the actor it judges; checks Gate A / Gate B / Gate C are present and load-bearing; seeds coherent-and-wrong artifacts to calibrate the monitors (flag rate not zero, not saturated); audits the loop's accumulated learned skills VIA the sl-monitoring-sl pattern; checks each known collapse mode is blocked by a stabilizer; and routes whatever an internal audit cannot self-certify to a disjoint base (external / cross-provider / hum

2026-06-290

use-case-b

canonical/squeeze-loop

The Squeeze Loop instance for Use Case B — an autonomous customer-refund bot that commits a terminal action (REIMBURSE | DENY | ESCALATE) and must resist multi-turn social engineering, on terrain B (authored authority). No external spec exists; the refund policy POL_REFUND_042 is authored upstream from an incident archive by an author who never sees the bot, and author independence is the whole soundness argument. Use when working on src/B — the refund policy, the headless REST app where only POST /action commits a verdict, the customer-history DB, the adjudicated-case archive, the adversarial scenario matrix, or the coherent-and-wrong "handles nominal distress but caves to legal coercion / duplicate-refund manipulation". Trigger phrasings: "use case B", "instance B", "refund bot squeeze", "authored policy / no external spec", "social-engineering resistance", "POST /action commits, chat never commits", "duplicate-refund / legal-coercion adversarial".

2026-06-270

use-case-d

canonical/squeeze-loop

The Squeeze Loop instance for Use Case D — formally verified Rocq (Coq) proofs of textbook arithmetic (e.g. commutativity of + on nat), on terrain A with a deductive lower bound (the Rocq kernel). The dominant failure is the prover discharging (Qed.) an adjacent weaker claim under the intended theorem name (e.g. right-identity n+0=n instead of n+m=m+n), or smuggling an axiom. The kernel (coqc) plus the axiom auditor (rocqchk --print-assumptions) is the immutable lower bound none of the actors can alter, and the exerciser authors false-theorem mutations the kernel must reject. Use when working on src/D — the textbook manifest, the formal theorem statement, the tactical proof, the false-theorem mutation matrix, the pinned Rocq stdlib, the prior-proofs regression registry, or the axiom audit. Trigger phrasings: "use case D", "instance D", "Rocq/Coq proof squeeze", "adjacent weaker theorem", "smuggled axiom / Admitted", "mutation must fail to compile", "Closed under the global context".

2026-06-270

sl-builder

canonical/squeeze-loop

Interview a human who wants to build a Squeeze Loop (SL) for their problem, then draft a concrete, structured plan. Elicits the deliverable, the upper bound (soft normative authority — spec/standard/policy/contracts), the lower bound (executable oracle — prover/checker/tests/runtime/reference impl), the actors and their disjoint (U,L) pairs, the context barriers, the gates (A editorial / B machine / C coverage-no-blend), the coherent-and-wrong failure to guard, and the stabilizers/collapse modes to pre-empt — then turns the answers into a roles+bounds+barriers+gates+loop-steps plan. Use when the user says any of: "draft a plan to generate a squeeze loop", "draft an SL validation plan", "build an SL strategy for X", "design a squeeze loop for my problem", "help me set up a squeeze loop", "SL validation plan for C code with Frama-C", "an SL that monitors another SL", "nested squeeze loop / monitor of a monitor". Action-oriented: figure out what is known, ASK the missing interview questions, then OUTPUT a plan i

2026-06-270

sl-monitoring-sl

canonical/squeeze-loop

Specifies how one squeeze loop monitors another squeeze loop — squeezing the monitored loop's soft outputs (especially its accumulated skills / learned heuristics) against that loop's own upper and lower bounds, from an independent evidence base; it classifies a skill by kind (ignore-signal vs defer-to-oracle), runs the matching consistency check, and repairs by carving over-generalized skills with bound-deferring exceptions or pruning spurious ones. Use when a loop accumulates or consolidates skills that may over-reach; when you need a meta-loop or monitor that audits a base loop's learned rules for contradictions with its spec; when a learned heuristic seems to conflict with the governing policy; or when reasoning about the "disjointness principle applied to skills." Trigger phrasings include "a loop monitoring a loop", "monitor the squeeze loop", "check a skill against the upper bound", "the skill contradicts the spec", "carve out an exception", "prune a spurious skill", "who audits the learned skill", "sk

2026-06-260

polish-skill

canonical/squeeze-loop

Polishes an existing SKILL.md file so it triggers reliably, scans well, and preserves every technical claim verbatim from the original; when a deep polish is warranted, it also splits cleanly into a SKILL.md plus reference files. Use whenever the user says "polish this skill", "clean up my skill", "make this skill better", "this SKILL.md is too long", uploads a `SKILL.md` file for polish, or asks for help reorganizing skill content under a `references/` folder. Also use when the user wants their skill checked for the common authoring failure modes: undertriggering descriptions, mis-numbered headings, mis-indented bullets, forward references, dead file paths, mixed cautionary-vs-canonical examples, run-on prose bullets, or a single `SKILL.md` past ~500 lines that should be broken up.

2026-06-210

name

use-case-c

description

Use Case C — the split-planes API squeeze loop

The dominant failure it guards

Terrain C — split planes

Correctness divides across two planes, each with its own authority:

Runtime plane — the API governance policy API_POLICY_081 (CLAUSE_1 auth, CLAUSE_2 uuid-only ids, CLAUSE_3 clean errors).
Document plane — the canonical OpenAPI contract base_schema.json (0444), read independently by both bands.

The soundness load rests on a no-blend cross-check: each plane is verified separately and the planes must agree.

The bounds

Upper bound U — both plane authorities (governance policy + canonical contract), which the sentinel refuses to let blend.
Lower bound L — the schema linter (document plane), the frozen app-state DB, the legacy route-signature regression oracle (ty0_baseline), and — for the exerciser — the live server observed over HTTP.

The cast (three actors) and the run-vs-read channel

Actor	Builds	`U`	`L`	Must not see
Gate sentinel / no-blend referee (coordinator)	the gate sequence + the `.sl.json`	both plane authorities	linter + runtime HTTP + frozen DB + legacy-signature regression + both bands	—
API implementer	the HTTP server + its published OpenAPI schema	policy + canonical contract	the frozen DB it serves; the linter its schema must pass	the conformance matrix
Conformance exerciser	the conformance test matrix	policy + canonical contract, read independently	what the live server returns when RUN over HTTP	the server source + the implementer's `openapi.json`

The gates

Gate A / isolation. The exerciser has zero import/path linkage to the server source.
Gate B (runtime). Status codes, exact response keys, no forbidden patterns (no id leaks, no tracebacks) on every tested route; plus the document-plane route cross-check.
Gate C (coverage / no-blend). Every clause maps to a passing check on its plane, seeded coherent-and-wrong negatives fire, and a clean check on one plane never stands in for the other; the legacy ty0 signature hash re-verifies (no regression).

Disjointness

python config/skills/sl-internal/scripts/sl_disjointness_check.py src/C/instance-c.sl.json

(0 FAIL / 8 checks.)