@brainervirus/workit-pi 5.0.0 → 6.0.1

package/README.md

@@ -1,26 +1,21 @@
 # @brainervirus/workit-pi
 
 [![CI](https://github.com/BrainerVirus/workit/actions/workflows/ci.yml/badge.svg)](https://github.com/BrainerVirus/workit/actions/workflows/ci.yml)
-[![license: MIT](https://img.shields.io/badge/license-MIT-green.svg)](../../LICENSE)
-
-Workit native extension for Pi (stock 0.85.1 package contract) — eight core-backed operation tools, eleven method skills, session/compaction continuity, and a coordinator that supervises fresh reviewer/investigator processes plus explicitly scoped implementers.
-
-## Requirements
-
-- **Node.js ≥ 24**
-- **Pi coding agent 0.85.1** (peer dependency)
-
-## Install
-
-Install this package alongside the Pi peer dependency. Pi discovers the
-extension and skills through the `pi` manifest section in `package.json`
-(`./dist/workit.js` plus `./skills`); see the Pi documentation for how it
-resolves extension packages in your setup.
-
-## Notes
-
-- Only an observed child process may acquire the shared writer; cancellation or restart uncertainty blocks replacement ownership.
-- The extension is a workflow control, not an OS sandbox: a supported literal
-  branch-creation command is checked against workspace naming policy; other
-  shell forms stay under the host's native permission rules.
-- Approval uses native `ctx.ui.confirm`, or `needs_input` when headless.
+[![license: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/BrainerVirus/workit/blob/main/LICENSE)
+
+[Workit](https://github.com/BrainerVirus/workit) for Pi (stock 0.85.1): a native extension with the
+seven task families plus read-only `workit_context`, the eleven method
+skills, session and compaction continuity, and a coordinator that launches
+fresh reviewer/investigator processes and scoped implementers. Requires
+Node.js 24+.
+
+```bash
+pi install npm:@brainervirus/workit-pi
+pi install ./packages/workit-pi -l --approve   # local checkout
+```
+
+Pi discovers the extension and skills from the package's `pi` manifest
+(`./dist/workit.js`, `./skills`). Pi project trust still gates mutations;
+shell writes are agent-guided, since an extension is not an OS sandbox.
+Delivery limits come from Pi's permissions plus the workspace
+[grants](https://github.com/BrainerVirus/workit/blob/main/docs/guides/grants.md).

package/dist/worker.js

@@ -7516,7 +7516,6 @@ var OPERATION_FAMILIES = [
   "finding",
   "decision",
   "worker",
-  "writer",
   "state"
 ];
 var uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
@@ -7599,20 +7598,13 @@ var refSchema = discriminatedUnion("kind", [
     id
   }).strict(),
   object({ kind: literal("host"), host: hostSchema, handle: nonEmpty }).strict(),
-  object({ kind: literal("external"), url: text.url() }).strict(),
-  object({
-    kind: literal("standing"),
-    workspace: nonEmpty,
-    class: nonEmpty,
-    configDigest: nullableDigest
-  }).strict()
+  object({ kind: literal("external"), url: text.url() }).strict()
 ]);
 var provenanceSchema = object({
   kind: _enum(["host_observed", "agent_reported", "imported"]),
   host: hostSchema,
   session: refSchema.nullable(),
-  workerId: nullableId,
-  receipts: array(refSchema)
+  workerId: nullableId
 }).strict();
 var entrySchema = (data) => object({ id, recordedAt: utc, provenance: provenanceSchema, data }).strict();
 var factSchema = object({
@@ -7855,22 +7847,13 @@ var decisionSchema = object({
     workspaceId: id,
     scope: scopeSchema,
     presented: text,
-    approvedContent: text,
-    displayed: text.optional(),
     contentRefs: array(refSchema),
-    statedChoice: object({ ref: text, text }).strict().optional(),
-    standing: object({ workspace: nonEmpty, class: nonEmpty }).strict().optional()
+    statedChoice: object({ ref: text, text }).strict().optional()
   }).strict(),
   digest,
   response: _enum(["approved", "rejected", "stated"]),
   requirementIds: array(digest),
-  revoked: object({ at: utc, reason: text }).strict().nullable(),
-  consumption: object({
-    state: _enum(["reserved", "consumed", "uncertain"]),
-    at: utc,
-    actionRef: refSchema,
-    historicalActionId: text.optional()
-  }).strict().nullable()
+  revoked: object({ at: utc, reason: text }).strict().nullable()
 }).strict();
 var findingSchema = object({
   claim: text,
@@ -7903,11 +7886,6 @@ var workerSchema = object({
   coordinator: refSchema.optional(),
   report: workerReportSchema.nullable()
 }).strict();
-var ownerSchema = object({
-  taskId: id,
-  workerId: nullableId,
-  session: object({ kind: literal("host"), host: hostSchema, handle: nonEmpty }).strict()
-}).strict();
 var closureSchema = object({
   outcome: outcomeSchema,
   at: utc,
@@ -7915,30 +7893,6 @@ var closureSchema = object({
   decisionIds: array(id),
   evidenceIds: array(id)
 }).strict();
-var actionProgressSchema = object({
-  decisionId: id,
-  steps: array(nonEmpty),
-  completedSteps: 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"]
-    });
-});
-var actionProgressListSchema = 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"]
-    });
-});
 var runtimeSchema = object({
   createdWith: text.nullable(),
   updatedWith: text
@@ -7964,7 +7918,6 @@ var taskRecordSchema = object({
   candidates: array(candidateSchema),
   evidence: array(entrySchema(evidenceSchema)),
   decisions: array(entrySchema(decisionSchema)),
-  actionProgress: actionProgressListSchema.optional(),
   findings: array(entrySchema(findingSchema)),
   workers: array(entrySchema(workerSchema)),
   critical: array(nonEmpty).optional()
@@ -7975,7 +7928,6 @@ var workspaceRecordSchema = object({
   revision,
   root: nonEmpty,
   runtime: runtimeSchema.optional(),
-  writer: object({ state: _enum(["held", "uncertain"]), owner: ownerSchema, acquiredAt: utc }).strict().nullable(),
   critical: array(nonEmpty).optional()
 }).strict();
 var capabilitySchema = object({
@@ -8011,8 +7963,7 @@ var taskSummarySchema = object({
   closure: closureSchema.nullable(),
   progress: progressSchema,
   policy: policySchema.nullable(),
-  requirements: array(requirementEvaluationSchema),
-  writer: workspaceRecordSchema.shape.writer
+  requirements: array(requirementEvaluationSchema)
 }).strict();
 var taskListItemSchema = taskSummarySchema.omit({ policy: true, requirements: true }).extend({ source: provenanceSchema.pick({ host: true, kind: true }) }).strict();
 var exportBundleSchema = object({
@@ -8072,8 +8023,7 @@ var taskOperations = {
     action: literal("resume"),
     ...taskId,
     ...revisions,
-    expectedWorkspaceRevision: revision.optional(),
-    authorityRefs: array(refSchema).optional()
+    expectedWorkspaceRevision: revision.optional()
   }),
   close: operation({
     action: literal("close"),
@@ -8168,30 +8118,12 @@ var workerOperations = {
     reason: text
   })
 };
-var writerOperations = {
-  acquire: operation({
-    action: literal("acquire"),
-    ...taskId,
-    expectedRevision: revision.optional(),
-    expectedWorkspaceRevision: revision.optional(),
-    workerId: nullableId.optional(),
-    reason: text.optional()
-  }),
-  release: operation({
-    action: literal("release"),
-    ...taskId,
-    expectedRevision: revision.optional(),
-    expectedWorkspaceRevision: revision.optional(),
-    reason: text.optional()
-  })
-};
 var stateOperations = {
   export: operation({ action: literal("export"), ...taskId }),
   import: operation({
     action: literal("import"),
     expectedWorkspaceRevision: revision.nullable().optional(),
-    bundle: exportBundleSchema,
-    authorityRefs: array(refSchema)
+    bundle: exportBundleSchema
   })
 };
 var operationSchemas = {
@@ -8201,7 +8133,6 @@ var operationSchemas = {
   finding: discriminatedUnion("action", Object.values(findingOperations)),
   decision: discriminatedUnion("action", Object.values(decisionOperations)),
   worker: discriminatedUnion("action", Object.values(workerOperations)),
-  writer: discriminatedUnion("action", Object.values(writerOperations)),
   state: discriminatedUnion("action", Object.values(stateOperations))
 };
 var withImplicitTask = (options) => Object.values(options).map((option) => ("taskId" in option.shape) ? option.extend({ taskId: id.optional() }) : option);
@@ -8213,7 +8144,6 @@ var advertisedOperationSchemas = {
   finding: advertised(findingOperations),
   decision: advertised(decisionOperations),
   worker: advertised(workerOperations),
-  writer: advertised(writerOperations),
   state: advertised(stateOperations)
 };
 var compiledOperationSchemas = Object.fromEntries(OPERATION_FAMILIES.map((family) => [family, compile(operationSchemas[family])]));
@@ -8293,8 +8223,24 @@ function candidateDigest(input) {
     head: input.head
   });
 }
-// packages/workit-core/src/core/task-store.ts
-import { AsyncLocalStorage } from "node:async_hooks";
+// packages/workit-core/src/core/package-root.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var packageRoot = () => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const parent = path.dirname(dir);
+    if (existsSync(path.join(dir, "package.json")) || parent === dir)
+      return dir;
+    dir = parent;
+  }
+};
+var assetRoot = () => {
+  const root = packageRoot();
+  const assets = path.join(root, "assets");
+  return existsSync(assets) ? assets : root;
+};
 
 // packages/workit-core/src/core/store-lock.ts
 var metadataLockSchema = object({
@@ -8342,11 +8288,10 @@ var SLOT = Symbol.for("workit.migrationReporter");
 var AUTO_COMPACT_BYTES = 2 * 1024 * 1024;
 var TOMBSTONE = Symbol("tombstone");
 var STALE_TEMPORARY_MS = 60 * 60000;
-var externalActionLockRoots = new AsyncLocalStorage;
 var heldInProcess = new Map;
-// packages/workit-core/src/core/workspaces.ts
-import path from "node:path";
-
+// packages/workit-core/src/git/rev.ts
+var MAX_BUFFER = 256 * 1024 * 1024;
+var MAX_UNTRACKED_BYTES = 5 * 1024 * 1024;
 // packages/workit-core/src/core/config.ts
 var PRESETS = {
   gitflow: {
@@ -8377,6 +8322,7 @@ var COMMIT_PRESETS = [
 ];
 
 // packages/workit-core/src/core/workspaces.ts
+import path2 from "node:path";
 var nonBlank = string2().refine((value) => value.trim().length > 0, "must not be blank");
 var branchPreset = custom((value) => typeof value === "string" && Object.hasOwn(PRESETS, value), "unsupported branch preset");
 var commitPreset = custom((value) => typeof value === "string" && COMMIT_PRESETS.includes(value), "unsupported commit preset");
@@ -8429,7 +8375,7 @@ var releaseTrackSchema = object({
       context.addIssue({ code: "custom", path: [field], message: "entries must be unique" });
     }
   }
-  if (track.versionSource.kind === "package-json" && (path.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
+  if (track.versionSource.kind === "package-json" && (path2.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
     context.addIssue({
       code: "custom",
       path: ["versionSource", "path"],
@@ -8447,6 +8393,11 @@ var workspaceConfigSchema = object({
     account: nonBlank.optional()
   }).passthrough().optional(),
   autoApprove: union([boolean2(), array(nonBlank)]).optional(),
+  defaultEndpoint: _enum(["commit", "pr"]).optional(),
+  autonomy: object(Object.fromEntries(["push", "pr", "merge", "release", "rerun"].map((kind) => [
+    kind,
+    union([boolean2(), literal("verified")]).optional()
+  ]))).passthrough().optional(),
   youtrack: object({ baseUrl: nonBlank.optional(), link_issues: boolean2().optional() }).passthrough().optional(),
   issues: object({ provider: literal("github").optional(), link_on_pr: boolean2().optional() }).passthrough().optional(),
   branchPolicy: workspaceBranchPolicySchema.optional(),
@@ -8486,126 +8437,6 @@ var workspacesFileSchema = object({ workspaces: array(workspaceConfigSchema).opt
 var runtimeWorkspaceIndexSchema = object({
   workspaces: array(object({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
 }).passthrough();
-
-// packages/workit-core/src/core/authority.ts
-var verifiedAuthorities = new WeakMap;
-
-// packages/workit-core/src/git/rev.ts
-var MAX_BUFFER = 256 * 1024 * 1024;
-var MAX_UNTRACKED_BYTES = 5 * 1024 * 1024;
-// packages/workit-core/src/core/external-action.ts
-var chainStepSchema = union([
-  string2().min(1),
-  object({ branch: string2().min(1) }).strict(),
-  object({ pr: literal(true) }).strict()
-]);
-var externalActionSchema = discriminatedUnion("operation", [
-  object({
-    operation: literal("git.branch_setup"),
-    payload: object({
-      action: _enum(["setup", "reapply_stash"]).optional(),
-      sdd_dir: string2().optional(),
-      target_branch: string2().optional(),
-      stash: _enum(["yes", "no"]).optional(),
-      cwd: string2().min(1).optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("git.commit"),
-    payload: object({
-      message: string2().min(1).optional(),
-      plan_steps: array(chainStepSchema).min(1).max(32).optional(),
-      plan_branch: string2().min(1).optional(),
-      cwd: string2().min(1).optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("git.push"),
-    payload: object({ branch: string2().min(1).optional(), cwd: string2().min(1).optional() }).strict()
-  }).strict(),
-  object({
-    operation: literal("hosting.pull_request"),
-    payload: object({
-      title: string2().min(1),
-      body: string2().optional(),
-      draft: boolean2().optional(),
-      target_branch: string2().optional(),
-      babysit: boolean2().optional(),
-      cwd: string2().min(1).optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("hosting.merge"),
-    payload: object({
-      target_branch: string2().min(1).optional(),
-      source_branch: string2().min(1).optional(),
-      cwd: string2().min(1).optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("hosting.delete_branch"),
-    payload: object({ branch: string2().min(1), cwd: string2().min(1).optional() }).strict()
-  }).strict(),
-  object({
-    operation: literal("youtrack.update"),
-    payload: object({
-      issueId: string2().min(1),
-      markdown: string2().min(1),
-      minutes: number2().positive().optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("youtrack.time"),
-    payload: object({
-      issueId: string2().min(1),
-      minutes: number2().positive(),
-      text: string2().optional(),
-      dateMs: number2().finite().optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("youtrack.meeting"),
-    payload: object({
-      issueId: string2().min(1),
-      minutes: number2().positive(),
-      text: string2().min(1)
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("changelog.apply"),
-    payload: object({
-      entries: union([
-        record(string2(), array(string2())),
-        array(object({ category: string2().min(1), text: string2().min(1) }).strict())
-      ]).optional(),
-      path: string2().optional(),
-      normalize_only: boolean2().optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("context.read"),
-    payload: object({
-      kind: _enum([
-        "git",
-        "pr",
-        "youtrack",
-        "github_issue",
-        "gitlab_issue",
-        "changelog",
-        "release",
-        "affected"
-      ]),
-      range: string2().optional(),
-      issueId: string2().optional(),
-      issueUrl: string2().optional(),
-      issueRef: string2().optional(),
-      mode: string2().optional(),
-      specPath: string2().optional(),
-      planPath: string2().optional(),
-      cwd: string2().min(1).optional()
-    }).strict()
-  }).strict()
-]);
 // packages/workit-core/src/core/policy-resolver.ts
 var resolverInputSchema = object({
   intent: intentSchema,
@@ -8621,7 +8452,6 @@ var resolverInputSchema = object({
 
 // packages/workit-core/src/core/task-engine.ts
 var verifiedWorkers = new WeakMap;
-var dispatchReservations = new WeakMap;
 var TASK_SCOPED_ACTIONS = new Set([
   "task.inspect",
   "task.revise",
@@ -8640,8 +8470,6 @@ var TASK_SCOPED_ACTIONS = new Set([
   "worker.assign",
   "worker.report",
   "worker.cancel",
-  "writer.acquire",
-  "writer.release",
   "state.export"
 ]);
 var CREATING_ACTIONS = new Set([
@@ -8651,10 +8479,37 @@ var CREATING_ACTIONS = new Set([
   "evidence.record",
   "finding.record",
   "decision.record",
-  "worker.assign",
-  "writer.acquire"
+  "worker.assign"
 ]);
 var retryPause = new Int32Array(new SharedArrayBuffer(4));
+// packages/workit-core/src/core/templates.ts
+var repoRoot = assetRoot();
+
+// packages/workit-core/src/core/scripts.ts
+var PLUGIN_ROOT = packageRoot();
+var ASSET_ROOT = assetRoot();
+
+// packages/workit-core/src/core/context-read.ts
+var contextReadSchema = object({
+  kind: _enum([
+    "git",
+    "pr",
+    "youtrack",
+    "github_issue",
+    "gitlab_issue",
+    "changelog",
+    "release",
+    "affected"
+  ]),
+  range: string2().optional(),
+  issueId: string2().optional(),
+  issueUrl: string2().optional(),
+  issueRef: string2().optional(),
+  mode: string2().optional(),
+  specPath: string2().optional(),
+  planPath: string2().optional(),
+  cwd: string2().min(1).optional()
+}).strict();
 // packages/workit-pi/src/worker-protocol.ts
 var MAX_WORKER_LINE_BYTES = 64 * 1024;
 var MAX_WORKER_STDERR_BYTES = 64 * 1024;
@@ -8789,14 +8644,12 @@ function launchWorker(assignment, options) {
     child: null,
     pid: null,
     spawned: false,
-    dispatch: null,
     state: "assigned",
     report: null,
     events: [],
     stdoutBuffer: "",
     stderr: "",
     exit: null,
-    writerReady: options.writerReady === true,
     ready: false,
     protocolError: null,
     pendingPrompt: options.pendingPrompt,
@@ -8927,57 +8780,13 @@ var consumeWorkerOutput = (handle, chunk) => {
 function sendWorkerPrompt(handle, prompt) {
   if (!handle.child?.stdin || handle.state !== "running" || !handle.ready)
     return false;
-  if (handle.assignment.role === "implementer" && !handle.writerReady)
-    return false;
   return handle.child.stdin.write(JSON.stringify({ id: "workit", type: "prompt", message: prompt }) + `
 `);
 }
-var prepareWorkerLaunch = (binding, handle) => {
-  const result = binding.core.prepareWorkerDispatch({
-    taskId: binding.taskId,
-    workerId: binding.workerId,
-    expectedRevision: binding.expectedRevision,
-    expectedWorkspaceRevision: binding.expectedWorkspaceRevision,
-    observation: { stage: "prepare", sessionId: handle.sessionId }
-  });
-  advanceBinding(binding, result);
-  if (result.ok)
-    handle.dispatch = result.data;
-  return result;
-};
-var commitWorkerNotStarted = (binding, handle) => {
-  const dispatch = handle.dispatch;
-  if (!dispatch)
-    return failure2("recovery_required", "worker launch reservation is not live");
-  const result = binding.core.commitWorkerDispatch({
-    dispatch,
-    taskId: binding.taskId,
-    workerId: binding.workerId,
-    expectedRevision: binding.expectedRevision,
-    expectedWorkspaceRevision: binding.expectedWorkspaceRevision,
-    outcome: "not_started",
-    session: null,
-    observation: { stage: "not_started", sessionId: handle.sessionId }
-  });
-  advanceBinding(binding, result);
-  if (result.ok)
-    handle.dispatch = null;
-  return result;
-};
 var observeWorkerStart = (binding, handle) => {
   const session = { kind: "host", host: "pi", handle: binding.sessionId };
   const observation = binding.observation ?? { pid: handle.pid, sessionId: handle.sessionId };
-  const dispatch = handle.dispatch;
-  const result = dispatch ? binding.core.commitWorkerDispatch({
-    dispatch,
-    taskId: binding.taskId,
-    workerId: binding.workerId,
-    expectedRevision: binding.expectedRevision,
-    expectedWorkspaceRevision: binding.expectedWorkspaceRevision,
-    outcome: "started",
-    session,
-    observation
-  }) : binding.core.observeWorkerLifecycle({
+  const result = binding.core.observeWorkerLifecycle({
     taskId: binding.taskId,
     workerId: binding.workerId,
     expectedRevision: binding.expectedRevision,
@@ -8986,8 +8795,6 @@ var observeWorkerStart = (binding, handle) => {
     session,
     observation
   });
-  if (dispatch && result.ok)
-    handle.dispatch = null;
   advanceBinding(binding, result);
   return result;
 };
@@ -9009,14 +8816,6 @@ var observeWorkerExit = (binding, handle, exit) => {
   advanceBinding(binding, result);
   return result;
 };
-var acquireWorkerWriter = (core, taskId, workerId, expectedRevision, expectedWorkspaceRevision) => core.writer({
-  schemaVersion: 1,
-  action: "acquire",
-  taskId,
-  workerId,
-  expectedRevision,
-  expectedWorkspaceRevision
-});
 var reportWorker = (core, taskId, workerId, report, expectedRevision, expectedWorkspaceRevision) => core.worker({
   schemaVersion: 1,
   action: "report",
@@ -9041,13 +8840,8 @@ var launchSupervisedWorker = (assignment, options) => {
     taskId: options.binding.taskId,
     workerId: options.binding.workerId,
     sessionId: options.binding.sessionId,
-    writerReady: assignment.role !== "implementer",
     pendingPrompt: options.prompt,
-    onPrepare: (pending) => {
-      if (options.onPrepare && !options.onPrepare(pending))
-        return false;
-      return prepareWorkerLaunch(options.binding, pending).ok;
-    },
+    onPrepare: (pending) => !options.onPrepare || options.onPrepare(pending),
     onSpawn: (spawned) => {
       if (options.onSpawn && !options.onSpawn(spawned))
         return false;
@@ -9068,26 +8862,6 @@ var launchSupervisedWorker = (assignment, options) => {
       options.onError?.(errored);
     },
     onReady: (readyHandle) => {
-      if (assignment.role === "implementer") {
-        const writer = acquireWorkerWriter(options.writerCore ?? options.binding.core, options.binding.taskId, options.binding.workerId, options.binding.expectedRevision, options.binding.expectedWorkspaceRevision);
-        readyHandle.writerReady = writer.ok;
-        advanceBinding(options.binding, writer);
-        if (!writer.ok) {
-          readyHandle.protocolError = "worker writer acquisition failed";
-          readyHandle.pendingPrompt = undefined;
-          const uncertaintyPersisted = options.onUncertain?.(readyHandle, {
-            state: "unknown",
-            observed: false,
-            code: null,
-            signal: null,
-            stderr: readyHandle.stderr
-          });
-          if (options.onUncertain && !uncertaintyPersisted)
-            readyHandle.protocolError = "worker uncertainty could not be persisted";
-          readyHandle.child?.kill("SIGTERM");
-          return;
-        }
-      }
       options.onReady?.(readyHandle);
     },
     onExit: (stopped, exit) => {
@@ -9102,19 +8876,6 @@ var launchSupervisedWorker = (assignment, options) => {
   return handle;
 };
 var nativeWorkerForEvidence = (getHandle) => ({
-  verifyDispatch: ({ expected, caller, observation }) => {
-    const handle = getHandle();
-    const observed = observation;
-    if (!handle || caller.host !== "pi" || expected.workerId !== handle.workerId || typeof observed !== "object" || observed === null || observed.stage !== expected.stage || observed.sessionId !== handle.sessionId || handle.spawned || handle.child !== null || handle.exit !== null)
-      return failure2("permission_denied", "Pi worker dispatch was not observed by the host");
-    return success(null, null, {
-      kind: "host_observed",
-      host: "pi",
-      session: { kind: "host", host: "pi", handle: caller.actor },
-      workerId: expected.workerId,
-      receipts: [{ kind: "host", host: "pi", handle: "dispatch:" + handle.sessionId }]
-    });
-  },
   verifyWorker: ({ expected, caller, observation }) => {
     const handle = getHandle();
     if (!handle || caller.host !== "pi" || expected.workerId !== handle.workerId || expected.session?.kind !== "host" || expected.session.host !== "pi" || expected.session.handle !== handle.sessionId || typeof observation !== "object" || observation === null || observation.pid !== handle.pid)
@@ -9128,8 +8889,7 @@ var nativeWorkerForEvidence = (getHandle) => ({
         kind: "host_observed",
         host: "pi",
         session: expected.session,
-        workerId: expected.workerId,
-        receipts: [{ kind: "host", host: "pi", handle: "pid:" + String(handle.pid ?? "unknown") }]
+        workerId: expected.workerId
       }
     };
   }
@@ -9147,8 +8907,7 @@ var nativeLostWorker = () => ({
         kind: "host_observed",
         host: "pi",
         session: expected.session,
-        workerId: expected.workerId,
-        receipts: [{ kind: "host", host: "pi", handle: "lost:" + expected.session.handle }]
+        workerId: expected.workerId
       }
     };
   }
@@ -9161,7 +8920,7 @@ async function cancelWorker(handle, options = {}) {
     return { state: "unknown", observed: false, code: null, signal: null, stderr: handle.stderr };
   };
   if (!handle.child) {
-    if (handle.spawned || !handle.dispatch || !options.binding || !commitWorkerNotStarted(options.binding, handle).ok)
+    if (handle.spawned)
       return uncertain();
     handle.state = "stopped";
     handle.exit = {
@@ -9212,7 +8971,6 @@ export {
   advanceWorkerBinding,
   cancelWorker,
   cancelWorkerAssignment,
-  commitWorkerNotStarted,
   consumeWorkerOutput,
   launchSupervisedWorker,
   launchWorker,
@@ -9222,7 +8980,6 @@ export {
   observeWorkerExit,
   observeWorkerStart,
   parseWorkerResult,
-  prepareWorkerLaunch,
   reconcileWorker,
   reportWorker,
   sendWorkerPrompt,