@brainervirus/workit-core 4.0.0 → 6.0.0

package/src/core/methods.ts

@@ -1,13 +1,13 @@
 import type { Assurance, Capability, Dimension, Policy } from "./task-contract";
 
 export type MethodId =
-  | "workit-challenge"
-  | "workit-behavioral-tdd"
+  | "workit-shape"
+  | "workit-bdd"
   | "workit-review"
-  | "workit-plan"
   | "workit-implement"
+  | "workit-fanout"
   | "workit-debug"
-  | "workit-handoff"
+  | "workit-continue"
   | "workit-deslop";
 
 type MethodDefinition = {
@@ -16,15 +16,16 @@ type MethodDefinition = {
 };
 
 export const METHODS: Readonly<Record<MethodId, MethodDefinition>> = {
-  "workit-challenge": { dimensions: ["challenge", "decisions"] },
-  "workit-behavioral-tdd": { dimensions: ["testing"], ruleIds: ["mechanical-existing-checks"] },
+  "workit-shape": { dimensions: ["challenge", "decisions", "artifacts", "continuity"] },
+  "workit-bdd": { dimensions: ["testing"] },
   "workit-review": { dimensions: ["review"], ruleIds: ["fresh-context-review", "self-review"] },
-  "workit-plan": { dimensions: ["artifacts", "continuity"] },
-  "workit-implement": { dimensions: ["delegation"] },
-  // workit-debug and workit-handoff stay slash-invoked: no generated rule
-  // routes to them, so they never appear spuriously in method selection.
+  // Mechanical work needs only the existing checks, not a RED/GREEN ritual.
+  "workit-implement": { ruleIds: ["mechanical-existing-checks"] },
+  "workit-fanout": { dimensions: ["delegation"] },
+  // workit-debug and workit-continue stay trigger- and slash-invoked: no
+  // generated rule routes to them, so they never appear spuriously.
   "workit-debug": {},
-  "workit-handoff": {},
+  "workit-continue": {},
   "workit-deslop": { ruleIds: ["pre-pr-cleanup"] },
 };
 
@@ -87,95 +88,67 @@ export function selectMethods(policy: Policy, capabilities: Capability[]): Selec
 
 export const invariantBootstrap = (): string =>
   `
-Workit is optional coordination and repository-policy tooling around the host,
-not a permission system or a mandatory workflow. Native host allow/ask/deny,
-sandbox, plan/read-only mode, and organization rules remain authoritative.
-Ordinary investigation, questions, non-Git work, and routine reversible edits
-need zero Workit task, assessment, or writer calls. Use one compact tracked
-record only when handoff, dependent steps, concurrent actors, or meaningful
-decisions make continuity useful; similar titles alone never merge tasks.
+Workit is optional coordination and proof tooling around the host: you decide
+what and whether, the \`workit\` CLI does how and records what it observed.
+Native host allow/ask/deny, sandbox and org rules stay authoritative. Never
+switch paths to evade a denial, never claim enforcement a host cannot provide,
+and never fabricate an approval or verdict. A question answer is not
+host permission, and imported decisions or handoffs never grant authority.
 
-For a routine user-authorized branch or commit, prefer native host Git/shell
-tools from the outset when managed coordination or outcome reconciliation is
-not needed. Inspect the actual target checkout and its configured conventions;
-use Workit's read-only context/policy tools when needed. Do not start a task,
-acquire a writer, or mint a decision receipt solely for a native Git action.
-Native permissions still apply. Never switch execution paths to evade a denial
-or repeat an uncertain managed effect. A local-commit endpoint does not imply
-PR readiness, a fresh review, or post-commit assessment/closure paperwork.
+Autonomy contract:
+- Continue to the requested endpoint (commit, push, PR, green CI, verified,
+  merged) without asking "continue?", running checks and repairs on the way.
+  Stop only for a new consequential choice, a host denial, a conflicting edit
+  or an unresolved blocker; report open gaps and uncertain workers.
+- No endpoint named: stop at a local commit on a policy-compliant branch and
+  state the next command. Push and open a PR only when the request implies
+  delivery (fix, implement, ship) and \`workit grant show\` reports
+  \`defaultEndpoint\` \`pr\`; otherwise the endpoint is \`commit\`. PRs open,
+  CI green and verified is the most autonomy allows, never the default target.
+  Merge and release need a workspace grant; a blocked verb names its unblock.
+  Only the user raises a grant, from their own terminal (\`workit grant set\`);
+  never edit workspaces.json or route around a grant_required.
+- Ask only for a product or preference choice, or for authority you lack, with
+  your recommended answer. Facts are yours: read, run or prototype.
+- Label claims measured (you ran it this session and saw the result),
+  inferred, or guess. Prose is a note: only a configured check the CLI ran
+  (\`workit check <name>\`) satisfies a gate; an ad-hoc
+  \`workit check -- <cmd>\` never does.
+- Author is not verifier: never record a passing verdict on work your session
+  wrote. The lead starts each verifier with its own session
+  (\`WORKIT_SESSION_ID=<lead>-v<n>\`; Claude Code subagents get one from the
+  hook), and the verifier records \`workit ledger verdict\`.
+- A local-commit endpoint does not imply PR readiness, and a local commit alone
+  is not evidence of a requested remote push. Before reporting delivery,
+  reconcile every requested item and observe it (\`workit verify-delivery\`).
 
-For tracked work, inspect its current state and use the shared operations for
-task, policy, evidence, finding, decision, worker, writer, and state changes.
-Each branch has one implicit task: an operation without taskId applies to it,
-and the first recording (a note, check, finding or evidence) creates it, so you
-never manage task ids. Start a record only for an explicit tracked objective;
-assess or reassess only
-when policy selection or changed evidence/constraints requires it. Omitted
-expectedRevision and expectedWorkspaceRevision use current values; explicit
-values are still concurrency-checked, so never copy revisions between calls.
-A busy result means another live Workit call holds the checkout lock: retry the
-same call; it is not a recovery condition. A lock left by a dead process is
-reclaimed on the next write, and \`workit doctor --fix-lock\` clears it on demand.
-An omitted revision absorbs a concurrent write: Workit re-reads, re-checks
-policy, and reapplies the call, returning busy under persistent contention. A
-revision_conflict means a revision you passed is stale: re-read the record
-before deciding whether to retry.
-A solo edit does not need writer acquisition; use it when concurrent checkout
-writers need coordination. Record only observed facts and checks. Close-time
-testing and verification gates accept only a configured check the CLI ran:
-\`workit check <name>\` (\`npx -y @brainervirus/workit-cli check <name>\` when
-\`workit\` is not on PATH); a recorded check result is a note and an ad-hoc
-\`workit check -- <cmd>\` never satisfies a gate. Evidence can become stale when its bound candidate or tree changes; reconcile findings against the
-current candidate before recording completion.
+CLI first: if a step has one right answer, use the \`workit\` verb instead of
+hand-running git, gh or glab: check, git, pr, ci, stack, verify-delivery,
+ledger, handoff, test-audit (\`workit help <verb>\`; without \`workit\` on
+PATH, \`npx -y @brainervirus/workit-cli\`). \`busy\` is retryable
+(\`workit doctor --fix-lock\` clears a dead lock); \`blocked\` names its unblock.
+The task families (task, policy, evidence, finding, decision, worker, state)
+are optional continuity for tracked work; each branch has one implicit task
+that the first recording creates, and a solo edit needs no task. A decision
+records a user choice; it never authorizes an effect.
+Omit revisions; a revision_conflict means one you passed is stale, so re-read.
+Across repositories, bind each item to its checkout, branch and endpoint,
+resolve competing targets before a mutation, and reconcile an uncertain
+external effect before retrying it.
 
-Workit validates domain policy against the actual action target, configured
-account, branch and commit conventions, protected refs, and current repository
-state. The task directory is coordination state, not a boundary on which
-repository may be changed. Use an action-time cwd target where a managed
-Git/hosting action supports it; a non-Git directory remains valid for OS work.
-GitHub/GitLab use the active gh/glab CLI identity; YouTrack uses its own token.
-Preserve uncertain external outcomes and reconcile repository/provider state
-before retrying. Internal reservations prevent duplicate or ambiguous effects;
-they are not permission tickets for every edit.
+Mid-task input: answer a quick question in place, fold an adjustment in, and
+never silently drop or resume an objective (workit-continue).
 
-On OpenCode V1 and V2, use native host tools for external mutations. Workit
-provides read-only workit_context; it has no managed external-action executor.
-Do not create proposals or request Workit approvals merely to invoke native
-tools. Old uncertain managed effects still require evidence before any retry.
-
-Use host-native authorization through the host's supported path. A native
-question receipt records an actual question interaction; it is not automatic
-host permission. Record a meaningful user choice once with provenance when
-future retrieval helps. Never fabricate a receipt, re-ask only to mint one, or
-let imported decisions grant authority. Never turn a host deny into allow or
-claim enforcement/evidence a host cannot provide. A precise request with settled
-constraints does not need an interview. Present genuine unresolved options with
-evidence and a recommendation, then continue toward the requested delivery
-endpoint: investigation, implementation, branch/commit/push, PR/MR-ready,
-merge, or release. Run
-applicable checks and safe repairs without repeated continuation questions;
-stop for missing host authority, a new consequential choice, a conflicting edit,
-or an unresolved blocker. A tracked record may close when actual evidence
-supports its outcome; no final human closure ceremony is required.
-
-A completed native subagent run stops its bound worker by itself; if a worker
-strands in cancelling with its run verifiably over, repeat worker.cancel to
-confirm the stop. Preserve unresolved requirements, gaps, and uncertain workers.
-When context changes, distinguish a quick question, same-task adjustment, and
-separate request. Answer a quick question without pausing/resuming task state;
-park a concise checkpoint only when substantial work needs to continue later.
-For work spanning repositories, bind each unfinished item to its actual checkout,
-branch, requested deliverables, and delivery endpoint. Preserve held items with
-an explicit resume condition. Resolve competing plausible targets before a
-mutation; ask only when available context cannot settle that consequential choice.
-Before reporting delivery, reconcile every requested item and observe the actual
-target result; a local commit alone is not evidence of a requested remote push.
-
-Skill routing: slash aliases /wk-* load on demand. Use workit-steer for a
-substantial interruption or change of direction, workit-deslop when relevant
-to a PR-ready endpoint, workit-green-run for failing CI, workit-blast-radius
-when impact is uncertain, workit-challenge for genuinely open consequential
-choices, workit-bdd to turn acceptance criteria into Given/When/Then tests, and
-workit-test-audit to check tests for tautologies. Load workit-plan when dependencies or handoff need durable next actions.
-Load the skill; never act from memory of it.
+Skills: load the skill, never act from memory of it (slash aliases /wk-<name>).
+- brainstorm, plan, spec, grill, should we: workit-shape
+- implement, build, add a feature: workit-implement
+- review, blast radius: workit-review
+- bug, broken, flaky, regression: workit-debug
+- ship, babysit, CI, merge: workit-ship
+- resume, pick up, handoff, interruption: workit-continue
+- BDD, TDD, acceptance criteria, Given/When/Then: workit-bdd
+- test audit, tautology, weak tests: workit-test-audit
+- deslop, slop, dead code: workit-deslop
+- fan out, parallelize, parallel agents, swarm: workit-fanout
+- verify the app, smoke test, prove it works: workit-verify-app
 `.trim();

package/src/core/skill-manifests.ts

@@ -2,44 +2,68 @@ import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 
 export const WORKIT_METHOD_SKILLS = [
-  "workit-challenge",
-  "workit-behavioral-tdd",
-  "workit-review",
-  "workit-plan",
+  "workit-shape",
   "workit-implement",
+  "workit-review",
   "workit-debug",
-  "workit-handoff",
-  "workit-babysit",
-  "workit-blast-radius",
-  "workit-deslop",
-  "workit-diagram",
-  "workit-mockup",
-  "workit-green-run",
-  "workit-steer",
+  "workit-ship",
+  "workit-continue",
   "workit-bdd",
   "workit-test-audit",
+  "workit-deslop",
+  "workit-fanout",
+  "workit-verify-app",
 ] as const;
 
+export type WorkitSkill = (typeof WORKIT_METHOD_SKILLS)[number];
+
 /** wk- slash aliases (one per skill): alias → method skill. An alias routes
  * through policy to model skills; an alias never calls another alias. */
 export const WORKIT_SKILL_ALIASES = {
-  "wk-challenge": "workit-challenge",
-  "wk-babysit": "workit-babysit",
+  "wk-shape": "workit-shape",
   "wk-implement": "workit-implement",
-  "wk-plan": "workit-plan",
-  "wk-debug": "workit-debug",
   "wk-review": "workit-review",
-  "wk-handoff": "workit-handoff",
-  "wk-tdd": "workit-behavioral-tdd",
-  "wk-blast-radius": "workit-blast-radius",
-  "wk-deslop": "workit-deslop",
-  "wk-diagram": "workit-diagram",
-  "wk-mockup": "workit-mockup",
-  "wk-green-run": "workit-green-run",
-  "wk-steer": "workit-steer",
+  "wk-debug": "workit-debug",
+  "wk-ship": "workit-ship",
+  "wk-continue": "workit-continue",
   "wk-bdd": "workit-bdd",
   "wk-test-audit": "workit-test-audit",
-} as const;
+  "wk-deslop": "workit-deslop",
+  "wk-fanout": "workit-fanout",
+  "wk-verify-app": "workit-verify-app",
+} as const satisfies Record<string, WorkitSkill>;
+
+/**
+ * The words a user types that should load each skill. Each skill's
+ * description and its bootstrap routing line carry every one of them, and no
+ * two skills share one (checked by test), so a trigger routes to one skill.
+ */
+export const WORKIT_SKILL_TRIGGERS: Readonly<Record<WorkitSkill, readonly string[]>> = {
+  "workit-shape": ["brainstorm", "plan", "spec", "grill", "should we"],
+  "workit-implement": ["implement", "build", "add a feature"],
+  "workit-review": ["review", "blast radius"],
+  "workit-debug": ["bug", "broken", "flaky", "regression"],
+  "workit-ship": ["ship", "babysit", "CI", "merge"],
+  "workit-continue": ["resume", "pick up", "handoff", "interruption"],
+  "workit-bdd": ["BDD", "TDD", "acceptance criteria", "Given/When/Then"],
+  "workit-test-audit": ["test audit", "tautology", "weak tests"],
+  "workit-deslop": ["deslop", "slop", "dead code"],
+  "workit-fanout": ["fan out", "parallelize", "parallel agents", "swarm"],
+  "workit-verify-app": ["verify the app", "smoke test", "prove it works"],
+};
+
+/** The `description:` frontmatter value of a SKILL.md (one line, unquoted). */
+export const skillDescription = (skillMd: string): string => {
+  const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(skillMd)?.[1] ?? "";
+  const line = /^description:\s*(.+)$/m.exec(frontmatter)?.[1] ?? "";
+  return line.trim().replace(/^(["'])(.*)\1$/, "$2");
+};
+
+/** A generated Cursor slash command for one alias; `commands/` is committed
+ * because Cursor discovers the plugin from git, so the build writes these and
+ * a drift test compares them to the committed copies. */
+export const cursorCommandText = (alias: string, skill: string, description: string): string =>
+  `# /${alias}\n\nLoad and apply the bundled \`${skill}\` skill. ${description}\n\nExtra context: $ARGUMENTS\n`;
 
 export const skillManifestNames = (root: string): string[] =>
   existsSync(root)

package/src/core/store-lock.ts

@@ -20,7 +20,6 @@ export type MetadataLock = {
   processStart: string | null;
   host: string;
   nonce: string;
-  externalAction?: true;
 };
 
 const metadataLockSchema = z
@@ -29,6 +28,7 @@ const metadataLockSchema = z
     processStart: z.string().nullable(),
     host: z.string().min(1),
     nonce: z.string().min(1),
+    /** Written by ≤4.x managed external actions; read and ignored (D17). */
     externalAction: z.literal(true).optional(),
   })
   .strict();

package/src/core/task-context.ts

@@ -109,7 +109,7 @@ const compactTimestamp = (value: Utc): string =>
   `${value.slice(0, 19)}.${value.slice(20, -1).padEnd(9, "0")}`;
 const compactDecisionChoice = (entry: TaskView["task"]["decisions"][number]): string | null => {
   const stated = entry.data.binding.statedChoice?.text;
-  const approved = entry.data.response === "approved" ? entry.data.binding.approvedContent : "";
+  const approved = entry.data.response === "approved" ? entry.data.binding.presented : "";
   const source = stated?.trim() || approved.trim() || null;
   return compactText(source, COMPACT_TEXT_BYTES);
 };

package/src/core/task-contract.ts

@@ -10,7 +10,6 @@ export const OPERATION_FAMILIES = [
   "finding",
   "decision",
   "worker",
-  "writer",
   "state",
 ] as const;
 export type OperationFamily = (typeof OPERATION_FAMILIES)[number];
@@ -145,19 +144,6 @@ export const refSchema = z.discriminatedUnion("kind", [
     .strict(),
   z.object({ kind: z.literal("host"), host: hostSchema, handle: nonEmpty }).strict(),
   z.object({ kind: z.literal("external"), url: text.url() }).strict(),
-  // Standing auto-approval receipt: authorizes without a live question while
-  // the referenced workspace rule covers the operation class. Verified live
-  // at reserve time against current config; dropped on export/import (a rule
-  // from another machine must never authorize here). Scalar-only shape keeps
-  // advertised operation schemas within provider depth limits.
-  z
-    .object({
-      kind: z.literal("standing"),
-      workspace: nonEmpty,
-      class: nonEmpty,
-      configDigest: nullableDigest,
-    })
-    .strict(),
 ]);
 export type Ref = z.infer<typeof refSchema>;
 
@@ -274,7 +260,6 @@ export const provenanceSchema = z
     host: hostSchema,
     session: refSchema.nullable(),
     workerId: nullableId,
-    receipts: z.array(refSchema),
   })
   .strict();
 export type Provenance = z.infer<typeof provenanceSchema>;
@@ -622,6 +607,13 @@ export const evidenceEvaluationSchema = z
   })
   .strict();
 export type EvidenceEvaluation = z.infer<typeof evidenceEvaluationSchema>;
+/**
+ * A durable decision record (D2, D18): agent-asserted like every other
+ * recording. It satisfies `decisions` requirements and accepted limitations;
+ * it never authorizes an external effect — autonomy grants and the host's
+ * own permission prompt do that. Legacy keys (`approvedContent`, `displayed`,
+ * `standing`, `consumption`) are dropped on read (D17).
+ */
 export const decisionSchema = z
   .object({
     purpose: z.enum(["design", "action", "limitation", "preference"]),
@@ -631,53 +623,18 @@ export const decisionSchema = z
         workspaceId: id,
         scope: scopeSchema,
         presented: text,
-        approvedContent: text,
-        displayed: text.optional(),
         contentRefs: z.array(refSchema),
         statedChoice: z.object({ ref: text, text: text }).strict().optional(),
-        standing: z.object({ workspace: nonEmpty, class: nonEmpty }).strict().optional(),
       })
       .strict(),
     digest,
     response: z.enum(["approved", "rejected", "stated"]),
     requirementIds: z.array(digest),
     revoked: z.object({ at: utc, reason: text }).strict().nullable(),
-    consumption: z
-      .object({
-        state: z.enum(["reserved", "consumed", "uncertain"]),
-        at: utc,
-        actionRef: refSchema,
-        /** Historical identifier only; never interpreted as native authority. */
-        historicalActionId: text.optional(),
-      })
-      .strict()
-      .nullable(),
   })
   .strict();
 export type Decision = z.infer<typeof decisionSchema>;
 
-/** Show-before-ask guard: binding questions are single-sentence and never
- * carry the artifact, descriptor, or payload body in the question UI. */
-export const BINDING_QUESTION_BUDGET = 300;
-const bindingQuestionHeader = /^Workit decision: (design|action|limitation|preference)$/;
-export const workitBindingQuestionIssue = (questions: unknown): string | null => {
-  if (!Array.isArray(questions) || questions.length !== 1) return null;
-  const question = questions[0] as { header?: unknown; question?: unknown; options?: unknown };
-  if (!question || typeof question !== "object") return null;
-  if (typeof question.header !== "string" || !bindingQuestionHeader.test(question.header.trim()))
-    return null;
-  const over = (label: string, value: string) =>
-    `invalid_input: ${label} is ${value.length} characters; Workit binding questions must stay within ${BINDING_QUESTION_BUDGET}. present the item in the conversation first, then ask a short scoped question.`;
-  if (typeof question.question === "string" && question.question.length > BINDING_QUESTION_BUDGET)
-    return over("the question text", question.question);
-  if (Array.isArray(question.options))
-    for (const option of question.options) {
-      const description = (option as { description?: unknown }).description;
-      if (typeof description === "string" && description.length > BINDING_QUESTION_BUDGET)
-        return over("an option description", description);
-    }
-  return null;
-};
 export const findingSchema = z
   .object({
     claim: text,
@@ -724,14 +681,6 @@ export const workerSchema = z
   })
   .strict();
 export type Worker = z.infer<typeof workerSchema>;
-export const ownerSchema = z
-  .object({
-    taskId: id,
-    workerId: nullableId,
-    session: z.object({ kind: z.literal("host"), host: hostSchema, handle: nonEmpty }).strict(),
-  })
-  .strict();
-export type Owner = z.infer<typeof ownerSchema>;
 export const closureSchema = z
   .object({
     outcome: outcomeSchema,
@@ -742,37 +691,6 @@ export const closureSchema = z
   })
   .strict();
 export type Closure = z.infer<typeof closureSchema>;
-export const actionProgressSchema = z
-  .object({
-    decisionId: id,
-    steps: z.array(nonEmpty),
-    completedSteps: z.array(nonEmpty),
-  })
-  .strict()
-  .check((ctx) => {
-    const { steps, completedSteps } = ctx.value;
-    const valid =
-      new Set(steps).size === steps.length &&
-      new Set(completedSteps).size === completedSteps.length &&
-      completedSteps.every((step, index) => steps[index] === step);
-    if (!valid)
-      ctx.issues.push({
-        code: "custom",
-        input: ctx.value,
-        message: "completed action steps must be a unique prefix of approved steps",
-        path: ["completedSteps"],
-      });
-  });
-export type ActionProgress = z.infer<typeof actionProgressSchema>;
-export const actionProgressListSchema = z.array(actionProgressSchema).check((ctx) => {
-  if (new Set(ctx.value.map((progress) => progress.decisionId)).size !== ctx.value.length)
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "action progress decision ids must be unique",
-      path: ["decisionId"],
-    });
-});
 export const runtimeSchema = z
   .object({
     createdWith: text.nullable(),
@@ -802,7 +720,6 @@ export const taskRecordSchema = z
     candidates: z.array(candidateSchema),
     evidence: z.array(entrySchema(evidenceSchema)),
     decisions: z.array(entrySchema(decisionSchema)),
-    actionProgress: actionProgressListSchema.optional(),
     findings: z.array(entrySchema(findingSchema)),
     workers: z.array(entrySchema(workerSchema)),
     /** Paths a reader must understand; see parseStoredRecord. */
@@ -917,10 +834,6 @@ export const workspaceRecordSchema = z
     revision,
     root: nonEmpty,
     runtime: runtimeSchema.optional(),
-    writer: z
-      .object({ state: z.enum(["held", "uncertain"]), owner: ownerSchema, acquiredAt: utc })
-      .strict()
-      .nullable(),
     /** Paths a reader must understand; see parseStoredRecord. */
     critical: z.array(nonEmpty).optional(),
   })
@@ -970,7 +883,6 @@ export const taskSummarySchema = z
     progress: progressSchema,
     policy: policySchema.nullable(),
     requirements: z.array(requirementEvaluationSchema),
-    writer: workspaceRecordSchema.shape.writer,
   })
   .strict();
 export type TaskSummary = z.infer<typeof taskSummarySchema>;
@@ -1046,7 +958,6 @@ const taskOperations = {
     ...taskId,
     ...revisions,
     expectedWorkspaceRevision: revision.optional(),
-    authorityRefs: z.array(refSchema).optional(),
   }),
   close: operation({
     action: z.literal("close"),
@@ -1141,30 +1052,12 @@ const workerOperations = {
     reason: text,
   }),
 };
-const writerOperations = {
-  acquire: operation({
-    action: z.literal("acquire"),
-    ...taskId,
-    expectedRevision: revision.optional(),
-    expectedWorkspaceRevision: revision.optional(),
-    workerId: nullableId.optional(),
-    reason: text.optional(),
-  }),
-  release: operation({
-    action: z.literal("release"),
-    ...taskId,
-    expectedRevision: revision.optional(),
-    expectedWorkspaceRevision: revision.optional(),
-    reason: text.optional(),
-  }),
-};
 const stateOperations = {
   export: operation({ action: z.literal("export"), ...taskId }),
   import: operation({
     action: z.literal("import"),
     expectedWorkspaceRevision: revision.nullable().optional(),
     bundle: exportBundleSchema,
-    authorityRefs: z.array(refSchema),
   }),
 };
 
@@ -1175,7 +1068,6 @@ export const operationSchemas = {
   finding: z.discriminatedUnion("action", Object.values(findingOperations) as any),
   decision: z.discriminatedUnion("action", Object.values(decisionOperations) as any),
   worker: z.discriminatedUnion("action", Object.values(workerOperations) as any),
-  writer: z.discriminatedUnion("action", Object.values(writerOperations) as any),
   state: z.discriminatedUnion("action", Object.values(stateOperations) as any),
 } as const;
 export type OperationRequest = z.infer<(typeof operationSchemas)[OperationFamily]>;
@@ -1198,7 +1090,6 @@ export const advertisedOperationSchemas = {
   finding: advertised(findingOperations),
   decision: advertised(decisionOperations),
   worker: advertised(workerOperations),
-  writer: advertised(writerOperations),
   state: advertised(stateOperations),
 } as const;
 export type TaskStartRequest = z.infer<typeof taskOperations.start>;
@@ -1222,7 +1113,6 @@ export type ErrorCode =
   | "permission_denied"
   | "capability_unavailable"
   | "requirements_unsatisfied"
-  | "writer_conflict"
   /** Retryable: another live Workit call holds the checkout's metadata lock. */
   | "busy"
   | "recovery_required"
@@ -1237,16 +1127,9 @@ export type ErrorDetails = {
   actualWorkspaceRevision?: Revision | null;
   requirementIds?: Digest[];
   capability?: string;
-  owner?: Owner;
   path?: string;
   operation?: string;
   outcome?: "not_started" | "pending" | "unknown";
-  /** Present when a native approval must be asked from a concise proposal. */
-  proposal?: {
-    presented: string;
-    approvedContent: string;
-    descriptorDigest: string;
-  };
   guidance?: string;
   /** Structured remedy for unsatisfied requirements: rule, reason, and
    * satisfaction text instead of opaque requirement hashes alone. */
@@ -1505,12 +1388,7 @@ const compareNullableText = (left: string | null, right: string | null): number
 const compareBooleanNullable = (left: boolean | null, right: boolean | null): number =>
   left === right ? 0 : left === null ? -1 : right === null ? 1 : Number(left) - Number(right);
 export function decisionDigest(input: Omit<Decision, "digest"> | Decision): Digest {
-  const {
-    digest: _ignored,
-    revoked: _revoked,
-    consumption: _consumption,
-    ...value
-  } = input as Decision;
+  const { digest: _ignored, revoked: _revoked, ...value } = input as Decision;
   return sha256(value);
 }
 export function candidateDigest(input: Candidate): Digest {