@astrosheep/keiyaku 4.5.9 → 4.5.11

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-workflow/SKILL.md

@@ -266,25 +266,41 @@ Deliver when the worktree content is the candidate you intend to land:
 keiyaku deliver <contract> --include-dirty
 ```
 
-Use `--include-dirty` only when the complete current workspace is the intended
-candidate; otherwise commit the intended bytes first. Read the receipt for the
-candidate, gate/placement stop, and any physical-effect lag. A not-complete
-delivery is still a recorded `tendered` candidate.
-
-`deliver` freshly tenders the candidate and requests placement. A current audit
-attestation is reused only when its integration snapshot and Verification
-segment still match; changes to the worktree, target, policy, document,
-Verification, or snapshot-producing options make it stale.
+Each `deliver` observes the target as it stands for that invocation, prepares
+the candidate's current-target integration in Keiyaku-owned Git custody, runs
+or reuses Verification, records the candidate, and requests placement. If the
+target moves, read the Contract and run `audit` or `deliver` again. Keiyaku
+recomputes the integration; a manual rebase is optional candidate shaping, not
+target refresh.
+
+Deliver when the work is ready to be judged, not when Git looks tidy. `git
+commit` only shapes the candidate; skipping it is fine — `deliver
+--include-dirty` captures the complete non-ignored worktree. If delivery reports
+an integration conflict, run `deliver --materialize-conflict`, resolve the
+judged conflict in the appointed worktree, then deliver the resolved bytes with
+`--include-dirty`.
+
+Deliver and review answer different questions: deliver records the candidate
+and places and claims by itself only when every placement obligation is current;
+a review gate is satisfied only by review testimony over the current candidate,
+and a satisfied review may itself be the invocation that places and claims.
+Reviewing before any delivery is legal but records testimony only — it creates
+no candidate and authorizes nothing. A Contract without a review gate needs no
+review.
+
+A current audit attestation is reused only when its integration snapshot and
+Verification segment still match; changes to the worktree, target, policy,
+document, Verification, or snapshot-producing options make it stale.
 
 ## Review Gates
 
 The Reviewer owns the answer. A gate review compares the full current candidate
 against every journaled Criterion — the floor that cannot be reduced — and
 testifies satisfied or unsatisfied over the current document identity and
-worktree; satisfied requests placement. A current defect, missing, failed, or
-stale required evidence, or terms too ambiguous or contradictory to judge all
-yield unsatisfied, with the summary naming what blocks. Advice beyond the terms
-belongs in the summary and never changes the verdict by itself.
+worktree. A current defect, missing, failed, or stale required evidence, or
+terms too ambiguous or contradictory to judge all yield unsatisfied, with the
+summary naming what blocks. Advice beyond the terms belongs in the summary and
+never changes the verdict by itself.
 
 ```bash
 keiyaku review <contract> --satisfied --summary "<conclusion>"
@@ -318,22 +334,22 @@ persist a train or add a second placement authority.
   gate-visible judgment for placement.
 - Before recording a satisfied review, or delivering a Contract with no
   declared gates, ask whether the exact patch will survive until placement. A
-  pure rebase whose `ChangeId` is unchanged keeps the existing review current;
-  do not re-review content addressing kept alive. Conflict resolution that
-  changes the `ChangeId` makes earlier testimony stale and requires a fresh
-  review: re-inspect the resolved candidate and record new testimony. Fresh
-  review follows the reviewer-reuse rule above; prefer the existing independent
-  reviewer when its judgment frame remains sound, especially so earlier findings
-  can be checked within the complete fresh judgment.
-- For Contracts known to overlap, resolve the current-target integration before
-  the authoritative review. Preliminary feedback may happen earlier, but it
-  is not a satisfied gate until its reviewed patch is the candidate intended
-  for placement. Land overlapping Contracts one at a time; let independent,
-  non-overlapping Contracts proceed without ceremony. Treat overlap as a
-  planning signal, not a correctness verdict.
+  freshly prepared current-target integration whose `ChangeId` is unchanged
+  keeps the existing review current; do not re-review content addressing kept
+  alive. Conflict resolution that changes the `ChangeId` makes earlier testimony
+  stale and requires a fresh review: re-inspect the resolved candidate and record
+  new testimony. Fresh review follows the reviewer-reuse rule above; prefer the
+  existing independent reviewer when its judgment frame remains sound, especially
+  so earlier findings can be checked within the complete fresh judgment.
+- For Contracts known to overlap, rerun `audit` or `deliver` against the current
+  target before the authoritative review. Preliminary feedback may happen
+  earlier, but it is not a satisfied gate until its reviewed patch is the
+  candidate intended for placement. Land overlapping Contracts one at a time;
+  let independent, non-overlapping Contracts proceed without ceremony. Treat
+  overlap as a planning signal, not a correctness verdict.
 - After target movement, a changed candidate, or a placement refusal, read the
   current Contract facts again. Recompute the next landing judgment from those
-  facts; do not rely on a remembered queue or promise exactly one rebase.
+  facts; do not rely on a remembered target or one-time integration.
 
 ## Target Placement
 

package/build/src/akuma/request-serve.js

@@ -43,7 +43,7 @@ async function projectCommandReceipt(input, fact, command, outcome, failure) {
 async function serveCommand(input, command) {
     const request = command.resolve(input.claim.payload);
     if (request === null)
-        return false;
+        throw new Error(`registered request action ${input.claim.action} rejected its payload`);
     let fact = await admitRequest(input.paths, {
         id: input.claim.id,
         action: input.claim.action,

package/build/src/cli/commands/contract-help.d.ts

@@ -0,0 +1,166 @@
+export type ContractFlagKind = "boolean" | "value" | "raw-value" | "repeat-value";
+export type ContractCommandSpec = Readonly<{
+    positional: "none" | "optional";
+    stdin: "none" | "optional" | "required";
+    flags: Readonly<Record<string, ContractFlagKind>>;
+    usage: string;
+    purpose: string;
+    details?: string;
+}>;
+export declare const CONTRACT_COMMAND_SPECS: {
+    readonly bind: {
+        readonly positional: "none";
+        readonly stdin: "optional";
+        readonly flags: {
+            readonly actor: "value";
+            readonly task: "value";
+            readonly target: "value";
+            readonly after: "repeat-value";
+            readonly gates: "raw-value";
+            readonly "fork-of": "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "bind [--task <task/...>] [--target <ref>] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] [--json] - | bind --fork-of <kei/...> [--target <ref>] [--actor <actor>] [--json]";
+        readonly purpose: "Create one Contract from stdin Markdown or a sibling fork.";
+    };
+    readonly amend: {
+        readonly positional: "optional";
+        readonly stdin: "optional";
+        readonly flags: {
+            readonly actor: "value";
+            readonly after: "repeat-value";
+            readonly "clear-after": "boolean";
+            readonly gates: "raw-value";
+            readonly json: "boolean";
+        };
+        readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name,...>] [--actor <actor>] [--json] [-]";
+        readonly purpose: "Amend one Contract's document operations or structured terms.";
+        readonly details: string;
+    };
+    readonly deliver: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly message: "value";
+            readonly "include-dirty": "boolean";
+            readonly "materialize-conflict": "boolean";
+            readonly json: "boolean";
+        };
+        readonly usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--materialize-conflict] [--json]";
+        readonly purpose: "Deliver your work as this Contract's candidate.";
+        readonly details: string;
+    };
+    readonly review: {
+        readonly positional: "optional";
+        readonly stdin: "optional";
+        readonly flags: {
+            readonly satisfied: "boolean";
+            readonly unsatisfied: "boolean";
+            readonly summary: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--json]";
+        readonly purpose: "Record one review verdict.";
+    };
+    readonly arc: {
+        readonly positional: "optional";
+        readonly stdin: "required";
+        readonly flags: {
+            readonly actor: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "arc [<contract>|@<contract>] [--actor <actor>] [--json] -";
+        readonly purpose: "Record stdin arc Markdown for one Contract.";
+    };
+    readonly abandon: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly actor: "value";
+            readonly note: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>] [--json]";
+        readonly purpose: "Abandon one Contract with an optional note.";
+    };
+    readonly status: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "status [<contract>|@name|<aku/...>]... [--json]";
+        readonly purpose: "Read the world status board or one or more Contract and Akuma projections.";
+    };
+    readonly show: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "show [<contract>|@<contract>] [--json]";
+        readonly purpose: "Read one Contract guidance projection.";
+    };
+    readonly ls: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "ls task[/] [--json]\nls kei[/] [--json]\nls aku[/] [--json]\nls aku/<akuma>[/] [--json]\nls \"aku/*/*\" [--json]";
+        readonly purpose: "List one identity directory.";
+    };
+    readonly audit: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly "include-dirty": "boolean";
+            readonly diff: "boolean";
+            readonly json: "boolean";
+        };
+        readonly usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--json]";
+        readonly purpose: "Ask what candidate preparation, Verification, and target placement would do.";
+    };
+    readonly reconcile: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly "retry-hooks": "boolean";
+            readonly json: "boolean";
+        };
+        readonly usage: "reconcile [<contract>|@<contract>] [--retry-hooks] [--json]";
+        readonly purpose: "Reconcile one Contract or the invocation world.";
+    };
+    readonly nuke: {
+        readonly positional: "none";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly confirm: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "nuke [--confirm <WorldRoot>] [--json]";
+        readonly purpose: "Remove Keiyaku-owned data from one confirmed World.";
+    };
+    readonly settings: {
+        readonly positional: "none";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "settings [--json]";
+        readonly purpose: "Show effective Settings (user + project, read-only)";
+    };
+    readonly region: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly path: "repeat-value";
+            readonly json: "boolean";
+        };
+        readonly usage: "region [<contract>] [--json]\nregion --path <pattern> [--path <pattern> ...] [--json]";
+        readonly purpose: "Read active declared Contract Regions.";
+    };
+};
+export type ContractCommand = keyof typeof CONTRACT_COMMAND_SPECS;
+export declare function renderContractHelp(command: ContractCommand): string;
+export declare function renderContractUsage(command: ContractCommand): string;

package/build/src/cli/commands/contract-help.js

@@ -0,0 +1,167 @@
+import { usageLine } from "../usage.js";
+export const CONTRACT_COMMAND_SPECS = {
+    bind: {
+        positional: "none",
+        stdin: "optional",
+        flags: {
+            actor: "value",
+            task: "value",
+            target: "value",
+            after: "repeat-value",
+            gates: "raw-value",
+            "fork-of": "value",
+            json: "boolean",
+        },
+        usage: "bind [--task <task/...>] [--target <ref>] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] [--json] - | bind --fork-of <kei/...> [--target <ref>] [--actor <actor>] [--json]",
+        purpose: "Create one Contract from stdin Markdown or a sibling fork.",
+    },
+    amend: {
+        positional: "optional",
+        stdin: "optional",
+        flags: { actor: "value", after: "repeat-value", "clear-after": "boolean", gates: "raw-value", json: "boolean" },
+        usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name,...>] [--actor <actor>] [--json] [-]",
+        purpose: "Amend one Contract's document operations or structured terms.",
+        details: [
+            "  ## Context|Objective|Design|Region|Criteria|Verification|<extension>  (replace, or add new extension)",
+            "  ## Replace: Context|Objective|Design|Region|Criteria|Verification|<extension>",
+            "  ## Append: Context|Objective|Design|Criteria|<extension>",
+            "  ## Add: Criteria|<new-extension-title>",
+            "  ## Update: <existing-extension-title>",
+            "  ## Remove: <existing-extension-title>",
+        ].join("\n"),
+    },
+    deliver: {
+        positional: "optional",
+        stdin: "none",
+        flags: {
+            message: "value",
+            "include-dirty": "boolean",
+            "materialize-conflict": "boolean",
+            json: "boolean",
+        },
+        usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--materialize-conflict] [--json]",
+        purpose: "Deliver your work as this Contract's candidate.",
+        details: [
+            "A clean worktree delivers its HEAD; --include-dirty captures every non-ignored",
+            "byte as an immutable commit object without changing the appointed worktree's HEAD",
+            "or real index. Runs or reuses Verification and requests placement: when every",
+            "prerequisite and declared gate is current, the same invocation places and claims.",
+            "Otherwise the candidate is recorded and the Contract is tendered. A prior git",
+            "commit is optional preparation — it never delivers, and delivering never",
+            "satisfies a review gate.",
+            "",
+            "  --include-dirty         Include all non-ignored worktree bytes, including an",
+            "                          unmerged shared index, in the candidate commit.",
+            "  --materialize-conflict  After a conflict result, project the judged targetHead",
+            "                          into the worktree as an uncommitted merge. Not a",
+            "                          delivery: resolve, then deliver with --include-dirty.",
+        ].join("\n"),
+    },
+    review: {
+        positional: "optional",
+        stdin: "optional",
+        flags: { satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" },
+        usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--json]",
+        purpose: "Record one review verdict.",
+    },
+    arc: {
+        positional: "optional",
+        stdin: "required",
+        flags: { actor: "value", json: "boolean" },
+        usage: "arc [<contract>|@<contract>] [--actor <actor>] [--json] -",
+        purpose: "Record stdin arc Markdown for one Contract.",
+    },
+    abandon: {
+        positional: "optional",
+        stdin: "none",
+        flags: { actor: "value", note: "value", json: "boolean" },
+        usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>] [--json]",
+        purpose: "Abandon one Contract with an optional note.",
+    },
+    status: {
+        positional: "optional",
+        stdin: "none",
+        flags: { json: "boolean" },
+        usage: "status [<contract>|@name|<aku/...>]... [--json]",
+        purpose: "Read the world status board or one or more Contract and Akuma projections.",
+    },
+    show: {
+        positional: "optional",
+        stdin: "none",
+        flags: { json: "boolean" },
+        usage: "show [<contract>|@<contract>] [--json]",
+        purpose: "Read one Contract guidance projection.",
+    },
+    ls: {
+        positional: "optional",
+        stdin: "none",
+        flags: { json: "boolean" },
+        usage: 'ls task[/] [--json]\nls kei[/] [--json]\nls aku[/] [--json]\nls aku/<akuma>[/] [--json]\nls "aku/*/*" [--json]',
+        purpose: "List one identity directory.",
+    },
+    audit: {
+        positional: "optional",
+        stdin: "none",
+        flags: { "include-dirty": "boolean", diff: "boolean", json: "boolean" },
+        usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--json]",
+        purpose: "Ask what candidate preparation, Verification, and target placement would do.",
+    },
+    reconcile: {
+        positional: "optional",
+        stdin: "none",
+        flags: { "retry-hooks": "boolean", json: "boolean" },
+        usage: "reconcile [<contract>|@<contract>] [--retry-hooks] [--json]",
+        purpose: "Reconcile one Contract or the invocation world.",
+    },
+    nuke: {
+        positional: "none",
+        stdin: "none",
+        flags: { confirm: "value", json: "boolean" },
+        usage: "nuke [--confirm <WorldRoot>] [--json]",
+        purpose: "Remove Keiyaku-owned data from one confirmed World.",
+    },
+    settings: {
+        positional: "none",
+        stdin: "none",
+        flags: { json: "boolean" },
+        usage: "settings [--json]",
+        purpose: "Show effective Settings (user + project, read-only)",
+    },
+    region: {
+        positional: "optional",
+        stdin: "none",
+        flags: { path: "repeat-value", json: "boolean" },
+        usage: "region [<contract>] [--json]\nregion --path <pattern> [--path <pattern> ...] [--json]",
+        purpose: "Read active declared Contract Regions.",
+    },
+};
+export function renderContractHelp(command) {
+    const spec = CONTRACT_COMMAND_SPECS[command];
+    if (command === "settings") {
+        return [
+            "Show effective Settings — the merged read-only view of:",
+            "  user      ~/.keiyaku/settings.json",
+            "  project   <WorldRoot>/.keiyaku/settings.json",
+            "A project record wholly shadows the same-name user record.",
+            "",
+            "Shape: namespace -> entry -> JSON value. There is no write",
+            "command; edit the files directly.",
+            "",
+            "Recognized settings:",
+            "  gates                            gate bundles selected by bind and amend",
+            "  worktree                         commands run when worktrees are created or destroyed",
+            "  git.requireBranchesToBeUpToDate  whether deliver and audit require up-to-date target branches",
+            "  providers                        the available Akuma and how each is run",
+            "",
+            "Each entry is validated by the feature that reads it. A rejected",
+            "value's diagnostic states the expected shape.",
+            "",
+            usageLine(spec.usage),
+        ].join("\n");
+    }
+    const help = `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+    return spec.details === undefined ? help : `${help}\n\n${spec.details}`;
+}
+export function renderContractUsage(command) {
+    return usageLine(CONTRACT_COMMAND_SPECS[command].usage);
+}

package/build/src/cli/commands/contract.d.ts

@@ -1,13 +1,6 @@
 import type { CatalogQuery } from "../../library/catalog.js";
-export type ContractFlagKind = "boolean" | "value" | "raw-value" | "repeat-value";
-export type ContractCommandSpec = Readonly<{
-    positional: "none" | "optional";
-    stdin: "none" | "optional" | "required";
-    flags: Readonly<Record<string, ContractFlagKind>>;
-    usage: string;
-    purpose: string;
-    details?: string;
-}>;
+import { type ContractCommand } from "./contract-help.js";
+export { CONTRACT_COMMAND_SPECS, renderContractHelp, renderContractUsage, type ContractCommand, type ContractCommandSpec, type ContractFlagKind, } from "./contract-help.js";
 type Output = Readonly<{
     output: "text" | "json";
 }>;
@@ -94,161 +87,6 @@ export type ParsedShow = Output & Readonly<{
     command: "show";
     contract?: string;
 }>;
-export declare const CONTRACT_COMMAND_SPECS: {
-    readonly bind: {
-        readonly positional: "none";
-        readonly stdin: "optional";
-        readonly flags: {
-            readonly actor: "value";
-            readonly task: "value";
-            readonly target: "value";
-            readonly after: "repeat-value";
-            readonly gates: "raw-value";
-            readonly "fork-of": "value";
-            readonly json: "boolean";
-        };
-        readonly usage: "bind [--task <task/...>] [--target <ref>] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] [--json] - | bind --fork-of <kei/...> [--target <ref>] [--actor <actor>] [--json]";
-        readonly purpose: "Create one Contract from stdin Markdown or a sibling fork.";
-    };
-    readonly amend: {
-        readonly positional: "optional";
-        readonly stdin: "optional";
-        readonly flags: {
-            readonly actor: "value";
-            readonly after: "repeat-value";
-            readonly "clear-after": "boolean";
-            readonly gates: "raw-value";
-            readonly json: "boolean";
-        };
-        readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name,...>] [--actor <actor>] [--json] [-]";
-        readonly purpose: "Amend one Contract's document operations or structured terms.";
-        readonly details: string;
-    };
-    readonly deliver: {
-        readonly positional: "optional";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly message: "value";
-            readonly "include-dirty": "boolean";
-            readonly "materialize-conflict": "boolean";
-            readonly json: "boolean";
-        };
-        readonly usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--materialize-conflict] [--json]";
-        readonly purpose: "Deliver one Contract candidate from the appointed worktree.";
-        readonly details: string;
-    };
-    readonly review: {
-        readonly positional: "optional";
-        readonly stdin: "optional";
-        readonly flags: {
-            readonly satisfied: "boolean";
-            readonly unsatisfied: "boolean";
-            readonly summary: "value";
-            readonly json: "boolean";
-        };
-        readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--json]";
-        readonly purpose: "Record one review verdict.";
-    };
-    readonly arc: {
-        readonly positional: "optional";
-        readonly stdin: "required";
-        readonly flags: {
-            readonly actor: "value";
-            readonly json: "boolean";
-        };
-        readonly usage: "arc [<contract>|@<contract>] [--actor <actor>] [--json] -";
-        readonly purpose: "Record stdin arc Markdown for one Contract.";
-    };
-    readonly abandon: {
-        readonly positional: "optional";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly actor: "value";
-            readonly note: "value";
-            readonly json: "boolean";
-        };
-        readonly usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>] [--json]";
-        readonly purpose: "Abandon one Contract with an optional note.";
-    };
-    readonly status: {
-        readonly positional: "optional";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly json: "boolean";
-        };
-        readonly usage: "status [<contract>|@name|<aku/...>]... [--json]";
-        readonly purpose: "Read the world status board or one or more Contract and Akuma projections.";
-    };
-    readonly show: {
-        readonly positional: "optional";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly json: "boolean";
-        };
-        readonly usage: "show [<contract>|@<contract>] [--json]";
-        readonly purpose: "Read one Contract guidance projection.";
-    };
-    readonly ls: {
-        readonly positional: "optional";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly json: "boolean";
-        };
-        readonly usage: "ls task[/] [--json]\nls kei[/] [--json]\nls aku[/] [--json]\nls aku/<akuma>[/] [--json]\nls \"aku/*/*\" [--json]";
-        readonly purpose: "List one identity directory.";
-    };
-    readonly audit: {
-        readonly positional: "optional";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly "include-dirty": "boolean";
-            readonly diff: "boolean";
-            readonly json: "boolean";
-        };
-        readonly usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--json]";
-        readonly purpose: "Ask what candidate preparation, Verification, and target placement would do.";
-    };
-    readonly reconcile: {
-        readonly positional: "optional";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly "retry-hooks": "boolean";
-            readonly json: "boolean";
-        };
-        readonly usage: "reconcile [<contract>|@<contract>] [--retry-hooks] [--json]";
-        readonly purpose: "Reconcile one Contract or the invocation world.";
-    };
-    readonly nuke: {
-        readonly positional: "none";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly confirm: "value";
-            readonly json: "boolean";
-        };
-        readonly usage: "nuke [--confirm <WorldRoot>] [--json]";
-        readonly purpose: "Remove Keiyaku-owned data from one confirmed World.";
-    };
-    readonly settings: {
-        readonly positional: "none";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly json: "boolean";
-        };
-        readonly usage: "settings [--json]";
-        readonly purpose: "Show effective Settings (user + project, read-only)";
-    };
-    readonly region: {
-        readonly positional: "optional";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly path: "repeat-value";
-            readonly json: "boolean";
-        };
-        readonly usage: "region [<contract>] [--json]\nregion --path <pattern> [--path <pattern> ...] [--json]";
-        readonly purpose: "Read active declared Contract Regions.";
-    };
-};
-export type ContractCommand = keyof typeof CONTRACT_COMMAND_SPECS;
 export type ParsedContractParts = Readonly<{
     command: ContractCommand;
     flags: Readonly<Record<string, string | true | readonly string[]>>;
@@ -258,7 +96,4 @@ export type ParsedContractParts = Readonly<{
     actor?: string;
 }>;
 export type ParsedContractCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedShow | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion;
-export declare function renderContractHelp(command: ContractCommand): string;
-export declare function renderContractUsage(command: ContractCommand): string;
 export declare function parseContractCommand(parts: ParsedContractParts): ParsedContractCommand;
-export {};