@brainervirus/workit-core 3.0.0 → 5.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,92 +88,64 @@ 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 a receipt, 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.
+- 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.
-Start a record once 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, writer,
+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 or writer.
+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

@@ -4,9 +4,11 @@ import { hostname } from "node:os";
 import path from "node:path";
 import * as z from "zod";
 import { canonicalJson } from "./task-contract";
+import { checkoutSlug, resolveStore } from "../store/paths";
 
 /**
- * Ownership rules for a checkout's `.workit/metadata.lock`.
+ * Ownership rules for the workit store's locks: a checkout's
+ * `checkouts/<slug>/metadata.lock` and each task's `tasks/<id>/lock`.
  *
  * The lock is a short mutex around one store mutation (or one managed effect).
  * A lock whose owner is gone is reclaimed automatically; a lock whose owner is
@@ -197,7 +199,16 @@ const ageOf = (file: string, nowMs: number): number | null => {
   }
 };
 
-export const lockPathFor = (root: string) => path.join(root, ".workit", "metadata.lock");
+/** A checkout's lock in the task store (see core/task-store.ts). */
+export const lockPathFor = (root: string): string => {
+  let real = path.resolve(root);
+  try {
+    real = fs.realpathSync(real);
+  } catch {}
+  const location = resolveStore(real);
+  const dir = location instanceof Error ? path.join(real, ".workit") : location.dir;
+  return path.join(dir, "checkouts", checkoutSlug(real), "metadata.lock");
+};
 
 /** Remove a reclaim guard abandoned by a crashed reclaimer. Returns true when removed. */
 export const clearAbandonedReclaimGuard = (lockPath: string, nowMs = Date.now()): boolean => {

package/src/core/task-contract.ts

@@ -1166,16 +1166,6 @@ const stateOperations = {
     bundle: exportBundleSchema,
     authorityRefs: z.array(refSchema),
   }),
-  recover: operation({
-    action: z.literal("recover"),
-    taskId: id.optional(),
-    expectedWorkspaceRevision: revision.optional(),
-    target: z.enum(["task", "workspace"]),
-    expectedBytes: digest,
-    snapshotDigest: digest,
-    reason: text,
-    authorityRefs: z.array(refSchema),
-  }),
 };
 
 export const operationSchemas = {
@@ -1191,16 +1181,25 @@ export const operationSchemas = {
 export type OperationRequest = z.infer<(typeof operationSchemas)[OperationFamily]>;
 
 /**
- * Schemas advertised to hosts. `state.recover` needs host-supplied native
- * recovery authority (`OperationContext.nativeRecovery`), which no shipped
- * host provides, so advertising it only sends agents into a guaranteed
- * permission_denied. parseOperation still accepts it for embedders that do
- * supply that authority.
+ * Schemas advertised to hosts. Every `taskId` is optional there: an operation
+ * without one applies to the implicit task of the caller's branch (D3); the
+ * engine fills it in before parsing against `operationSchemas`.
  */
-const { recover: _unadvertisedRecover, ...advertisedStateOperations } = stateOperations;
+const withImplicitTask = (options: Record<string, z.ZodObject>) =>
+  Object.values(options).map((option) =>
+    "taskId" in option.shape ? option.extend({ taskId: id.optional() }) : option,
+  );
+const advertised = (options: Record<string, z.ZodObject>) =>
+  z.discriminatedUnion("action", withImplicitTask(options) as any);
 export const advertisedOperationSchemas = {
-  ...operationSchemas,
-  state: z.discriminatedUnion("action", Object.values(advertisedStateOperations) as any),
+  task: advertised(taskOperations),
+  policy: advertised(policyOperations),
+  evidence: advertised(evidenceOperations),
+  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>;
 

package/src/core/task-engine.ts

@@ -39,6 +39,7 @@ import {
   type Utc,
   type Provenance,
   type Worker,
+  type OperationFamily,
   type WorkspaceRecord,
   taskRecordSchema,
 } from "./task-contract";
@@ -62,7 +63,8 @@ import {
 } from "./authority";
 import { diffPolicy, resolvePolicy } from "./policy-resolver";
 import { verifyStandingApproval } from "./auto-approval";
-import { TaskStore, type MetadataLock, type ProcessEvidence } from "./task-store";
+import { sameDirectoryIdentity, TaskStore } from "./task-store";
+import { checkoutRootOf } from "../store/paths";
 import { defaultLockTimeout } from "./store-lock";
 import {
   compactTaskContext,
@@ -108,12 +110,6 @@ export type OperationContext = {
   now: Utc | (() => Utc);
   nativeAuthority?: NativeAuthorityVerifier;
   nativeWorker?: NativeWorkerVerifier;
-  nativeRecovery?: (input: {
-    lock: MetadataLock | null;
-    writer: WorkspaceRecord["writer"];
-    reason: string;
-    authorityRefs: Ref[];
-  }) => Result<ProcessEvidence>;
   workerId?: string | null;
 };
 
@@ -466,6 +462,40 @@ const refsWithinScope = (refs: Ref[], scope: Scope): boolean =>
       bindingCovers(scope, { description: "", paths: [ref.path], exclusions: [] }),
   );
 
+/** Actions that take a taskId; without one they apply to the implicit task. */
+const TASK_SCOPED_ACTIONS: ReadonlySet<string> = new Set([
+  "task.inspect",
+  "task.revise",
+  "task.progress",
+  "task.pause",
+  "task.resume",
+  "task.close",
+  "policy.assess",
+  "policy.preview",
+  "policy.explain",
+  "evidence.record",
+  "finding.record",
+  "finding.resolve",
+  "decision.record",
+  "decision.revoke",
+  "worker.assign",
+  "worker.report",
+  "worker.cancel",
+  "writer.acquire",
+  "writer.release",
+  "state.export",
+]);
+/** Recording actions that create the implicit task on first use. */
+const CREATING_ACTIONS: ReadonlySet<string> = new Set([
+  "task.revise",
+  "task.progress",
+  "policy.assess",
+  "evidence.record",
+  "finding.record",
+  "decision.record",
+  "worker.assign",
+  "writer.acquire",
+]);
 /** Commit attempts for a call whose revisions the engine filled (see retryFilledRevisions). */
 const REVISION_RETRY_ATTEMPTS = 8;
 const retryPause = new Int32Array(new SharedArrayBuffer(4));
@@ -777,7 +807,10 @@ export class WorkitCore {
 
   private contextRootError(): Result<null> {
     try {
-      if (realpathSync(this.context.root) !== this.store.root)
+      // The same checkout: any directory inside it resolves to its top level.
+      realpathSync(this.context.root);
+      const root = checkoutRootOf(this.context.root);
+      if (root !== this.store.root && !sameDirectoryIdentity(root, this.store.root))
         return failure(
           "invalid_input",
           "operation context root does not match the task store root",
@@ -820,6 +853,36 @@ export class WorkitCore {
     return retryFilledRevisions(filledRevisions(request), run);
   }
 
+  /**
+   * A task-scoped request without a `taskId` applies to the implicit task of
+   * this checkout's branch (D3). Recording actions create that task on first
+   * use; reads and lifecycle actions only look it up. Helpers never create.
+   */
+  private implicitTask(family: OperationFamily, request: unknown): Result<unknown> {
+    if (typeof request !== "object" || request === null || Array.isArray(request))
+      return success(null, null, request);
+    const value = request as { action?: unknown; taskId?: unknown };
+    if (value.taskId !== undefined || typeof value.action !== "string")
+      return success(null, null, request);
+    const action = `${family}.${value.action}`;
+    if (!TASK_SCOPED_ACTIONS.has(action)) return success(null, null, request);
+    const root = this.contextRootError();
+    if (!root.ok) return root;
+    const create = CREATING_ACTIONS.has(action) && (this.context.workerId ?? null) === null;
+    const found = this.store.implicitTask({
+      provenance: provenance(this.context),
+      create,
+      now: trustedNow(this.context),
+    });
+    if (!found.ok) return found;
+    if (!found.data)
+      return failure(
+        "not_found",
+        'no task for this branch yet; pass taskId, or record something first (`workit task start "<objective>"`, a note, a check) to create it',
+      );
+    return success(null, null, { ...request, taskId: found.data.task.id });
+  }
+
   private helperEntry(
     task: TaskRecord,
     requireSession = false,
@@ -859,10 +922,12 @@ export class WorkitCore {
   }
 
   state(request: unknown): Result<ExportBundle | TaskSummary | TaskRecord | WorkspaceRecord> {
-    // Recovery is an operator CAS over snapshot bytes; only import retries.
-    return (request as { action?: unknown } | null)?.action === "import"
-      ? this.retryOmittedRevisions(request, () => this.stateOnce(request))
-      : this.stateOnce(request);
+    const resolved = this.implicitTask("state", request);
+    if (!resolved.ok) return resolved;
+    const value = resolved.data;
+    return (value as { action?: unknown } | null)?.action === "import"
+      ? this.retryOmittedRevisions(value, () => this.stateOnce(value))
+      : this.stateOnce(value);
   }
 
   private stateOnce(
@@ -932,47 +997,14 @@ export class WorkitCore {
       if (!imported.ok) return imported;
       return this.summary(imported.data);
     }
-    if (!this.context.nativeRecovery)
-      return failure("permission_denied", "native recovery authority is unavailable");
-    const processEvidence = (
-      lock: MetadataLock | null,
-      writer: WorkspaceRecord["writer"],
-    ): Result<ProcessEvidence> =>
-      this.context.nativeRecovery!({
-        lock,
-        writer,
-        reason: input.reason,
-        authorityRefs: input.authorityRefs,
-      });
-    if (input.target === "workspace")
-      return this.store.recoverWorkspace({
-        expectedBytes: input.expectedBytes,
-        snapshotDigest: input.snapshotDigest,
-        reason: input.reason,
-        authorityRefs: input.authorityRefs,
-        expectedWorkspaceRevision: input.expectedWorkspaceRevision,
-        processEvidence,
-      });
-    const workspace = this.store.readWorkspace();
-    if (!workspace.ok) return workspace;
-    if (!workspace.data) return failure("not_found", "workspace not found");
-    this.fillRevisions(input, undefined, workspace.data);
-    if (input.target === "workspace" && input.taskId !== undefined)
-      return failure("invalid_input", "workspace recovery takes no task ID");
-    if (input.target === "task" && input.taskId === undefined)
-      return failure("invalid_input", "task recovery requires a task ID");
-    return this.store.recoverTask(input.taskId, {
-      expectedBytes: input.expectedBytes,
-      snapshotDigest: input.snapshotDigest,
-      reason: input.reason,
-      authorityRefs: input.authorityRefs,
-      expectedWorkspaceRevision: input.expectedWorkspaceRevision,
-      processEvidence,
-    });
+    return failure("invalid_input", "unknown state action");
   }
 
   task(request: unknown): Result<TaskSummary | TaskListItem[] | TaskView> {
-    return this.retryOmittedRevisions(request, () => this.taskOnce(request));
+    const resolved = this.implicitTask("task", request);
+    if (!resolved.ok) return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.taskOnce(value));
   }
 
   private taskOnce(request: unknown): Result<TaskSummary | TaskListItem[] | TaskView> {
@@ -1083,7 +1115,10 @@ export class WorkitCore {
   }
 
   policy(request: unknown): Result<Policy | null> {
-    return this.retryOmittedRevisions(request, () => this.policyOnce(request));
+    const resolved = this.implicitTask("policy", request);
+    if (!resolved.ok) return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.policyOnce(value));
   }
 
   private policyOnce(request: unknown): Result<Policy | null> {
@@ -1139,7 +1174,10 @@ export class WorkitCore {
   }
 
   evidence(request: unknown): Result<Entry<Evidence>> {
-    return this.retryOmittedRevisions(request, () => this.evidenceOnce(request));
+    const resolved = this.implicitTask("evidence", request);
+    if (!resolved.ok) return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.evidenceOnce(value));
   }
 
   private evidenceOnce(request: unknown): Result<Entry<Evidence>> {
@@ -1339,11 +1377,13 @@ export class WorkitCore {
   }
 
   decision(request: unknown): Result<Entry<Decision>> {
-    return this.recordDecision(request);
+    const resolved = this.implicitTask("decision", request);
+    return resolved.ok ? this.recordDecision(resolved.data) : resolved;
   }
 
   observeDecision(request: unknown, observation: unknown): Result<Entry<Decision>> {
-    return this.recordDecision(request, observation, true);
+    const resolved = this.implicitTask("decision", request);
+    return resolved.ok ? this.recordDecision(resolved.data, observation, true) : resolved;
   }
 
   /**
@@ -1353,7 +1393,8 @@ export class WorkitCore {
    * removal, which fails the next reserve closed.
    */
   observeStandingDecision(request: unknown): Result<Entry<Decision>> {
-    return this.recordDecision(request, undefined, true, true);
+    const resolved = this.implicitTask("decision", request);
+    return resolved.ok ? this.recordDecision(resolved.data, undefined, true, true) : resolved;
   }
 
   /**
@@ -1576,7 +1617,10 @@ export class WorkitCore {
   }
 
   finding(request: unknown): Result<Entry<Finding>> {
-    return this.retryOmittedRevisions(request, () => this.findingOnce(request));
+    const resolved = this.implicitTask("finding", request);
+    if (!resolved.ok) return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.findingOnce(value));
   }
 
   private findingOnce(request: unknown): Result<Entry<Finding>> {
@@ -1749,7 +1793,10 @@ export class WorkitCore {
   }
 
   worker(request: unknown): Result<Entry<Worker>> {
-    return this.retryOmittedRevisions(request, () => this.workerOnce(request));
+    const resolved = this.implicitTask("worker", request);
+    if (!resolved.ok) return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.workerOnce(value));
   }
 
   private workerOnce(request: unknown): Result<Entry<Worker>> {
@@ -2188,7 +2235,10 @@ export class WorkitCore {
   }
 
   writer(request: unknown): Result<WorkspaceRecord> {
-    return this.retryOmittedRevisions(request, () => this.writerOnce(request));
+    const resolved = this.implicitTask("writer", request);
+    if (!resolved.ok) return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.writerOnce(value));
   }
 
   private writerOnce(request: unknown): Result<WorkspaceRecord> {