@bermudi/pi-delegate 0.1.18 → 0.1.20

package/types.ts

@@ -84,6 +84,8 @@ export interface TicketWaiter {
 }
 
 export interface AsyncTicket {
+  /** Orthogonal to lifecycle status: paused tickets remain live reservations. */
+  pause?: import("./pause.ts").PauseController;
   id: string;
   created: number;
   completedAt?: number;
@@ -119,6 +121,9 @@ export interface AsyncTicket {
   workersSettled?: boolean;
   /** Batch-level warning attached to this dispatch, not to any one task. */
   dispatchWarning?: string;
+  /** Batch-level notice that overlapping shared writers were serialized into
+   *  task order instead of rejected. Informational, not a warning. */
+  serializedNotice?: string;
   /** Immutable dispatch-scoped delegate.json snapshot used by async workers and
    *  later result formatting. */
   config?: import("./config.ts").DelegateConfig;
@@ -250,6 +255,12 @@ export type TaskFailureKind =
   "cancelled" | "stalled" | "model_error" | "deadline_exceeded";
 
 export interface TaskProgress {
+  /** Bounded assistant-text tail for the live browser; no private thinking. */
+  assistantPreview?: string;
+  activity?: string;
+  /** Index of the same-call writer this task must follow. */
+  waitingFor?: number;
+  paused?: boolean;
   id?: string;
   index: number;
   agent: string;
@@ -275,6 +286,7 @@ export interface TaskProgress {
 }
 
 export interface DelegateDetails {
+  pauseState?: import("./pause.ts").PauseState;
   tasks: TaskDef[];
   results: (TaskResult | { error: string })[];
   progress: TaskProgress[];
@@ -291,9 +303,14 @@ export interface DelegateDetails {
   overlapWarning?: string;
   /** Warning that applies to the whole dispatch rather than an individual task. */
   dispatchWarning?: string;
+  /** Notice that overlapping shared writers in this dispatch were serialized
+   *  into task order instead of rejected. Informational, not a warning. */
+  serializedNotice?: string;
 }
 
 export interface TaskResult {
+  /** Batch-local ordered-writer group; never suppress incomplete evidence. */
+  serializedGroup?: number;
   id?: string;
   agent: string;
   /** Short tag (via `formatResumeTag`) of the transcript this task continued
@@ -342,6 +359,7 @@ export interface TaskResult {
 export type TaskIntegrationStatus =
   | "applied_unverified"
   | "no_changes"
+  | "retained"
   | "conflict"
   | "discarded"
   | "apply_failed";
@@ -381,6 +399,15 @@ export type TaskIntegration =
        * paths. They do not turn the discarded proposal into an apply failure. */
       classificationIssues?: Array<{ path: string; reason: string }>;
     })
+  | (TaskIntegrationFiles & {
+      status: "retained";
+      reason: string;
+      baselineRef: string;
+      proposalRef: string;
+      patchPath: string;
+      worktreePath?: string;
+      conflicts?: never;
+    })
   | (TaskIntegrationFiles & {
       status: "conflict";
       conflicts: Array<{ path: string; reason: string }>;
@@ -410,6 +437,8 @@ export interface AgentRunConfig {
 }
 
 export interface AgentProgressUpdate {
+  assistantPreview?: string;
+  activity?: string;
   tokens: number;
   toolUses: number;
   durationMs: number;
@@ -420,6 +449,7 @@ export interface AgentProgressUpdate {
 }
 
 export interface TaskRunEnv {
+  pause?: import("./pause.ts").PauseController;
   /** Abort signal — parent's for sync, ticket's for async. May be undefined when no parent signal is available. */
   signal: AbortSignal | undefined;
   modelRegistry: ModelRegistry;
@@ -444,6 +474,9 @@ export interface TaskRunEnv {
    *  use this instead of the live singleton so retry/stall/output/provider
    *  settings stay stable for the ticket's lifetime. */
   config?: import("./config.ts").DelegateConfig;
+  /** Injectable runtime context. When omitted, task execution falls back to the
+   *  module-level default runtime for backward compatibility. */
+  runtime?: import("./runtime.ts").DelegateRuntime;
 }
 
 /** Structural subset of Pi's `ExtensionContext` used by delegate's

package/workspace.ts

@@ -280,9 +280,10 @@ async function assertGitMetadataContained(
   root: string,
   signal: AbortSignal,
 ): Promise<void> {
-  const hasGitDir = await fs.promises
-    .stat(path.join(root, ".git"))
-    .then((stat) => stat.isDirectory(), () => false);
+  const hasGitDir = await fs.promises.stat(path.join(root, ".git")).then(
+    (stat) => stat.isDirectory(),
+    () => false,
+  );
   if (!hasGitDir) return;
   const effectiveWorktree = path.resolve(
     (
@@ -749,6 +750,57 @@ async function sweepStaleScratchLeases(
   }
 }
 
+/** Read-only pre-flight every scratch creation runs before anything exists:
+ * canonical cwd, safe project-root discovery, and the shared tree/git-metadata
+ * rule. Fast-fails on blockers that are knowable before a container, lease, or
+ * copy is created — a rejection here costs milliseconds instead of a doomed
+ * reflink copy. The post-copy validation stays the authority for trees that
+ * change mid-copy. Throws `ScratchSetupError` on any deterministic blocker. */
+async function resolveScratchSource(
+  cwd: string,
+  signal: AbortSignal,
+  parentSignal: AbortSignal | undefined,
+): Promise<{ sourceCwd: string; sourceRoot: string }> {
+  throwIfSetupCancelled(signal, parentSignal);
+  const sourceCwd = await fs.promises.realpath(cwd);
+  throwIfSetupCancelled(signal, parentSignal);
+  const sourceRoot = await findCopyRoot(sourceCwd, signal);
+  throwIfSetupCancelled(signal, parentSignal);
+  if (!isWithin(sourceRoot, sourceCwd)) {
+    throw new ScratchSetupError(
+      "Scratch workspace could not map the task cwd into its project root.",
+    );
+  }
+  await validateScratchTree(
+    sourceRoot,
+    sourceRoot,
+    false,
+    signal,
+    parentSignal,
+  );
+  await assertGitMetadataContained(sourceRoot, signal);
+  return { sourceCwd, sourceRoot };
+}
+
+/** Verify that scratch setup would proceed for `cwd`, without creating
+ * anything: the same pre-flight `createScratchWorkspace` runs before any
+ * container, lease, or copy exists (one walker, one rule — the post-copy
+ * validation stays the authority for trees that change mid-copy). Throws
+ * `ScratchSetupError` with the same message setup would produce, so callers
+ * can recommend scratch only where it can actually run. */
+export async function checkScratchWorkspaceSupport(
+  cwd: string,
+  signal?: AbortSignal,
+): Promise<void> {
+  if (process.platform !== "linux" || !fs.existsSync("/proc/self/fd")) {
+    throw new ScratchSetupError(
+      "Scratch workspaces require Linux with GNU cp and /proc/self/fd available.",
+    );
+  }
+  const active = signal ?? new AbortController().signal;
+  await resolveScratchSource(cwd, active, active);
+}
+
 /**
  * Make an ephemeral, same-filesystem CoW copy of the Git repository containing
  * cwd (or cwd itself outside Git). This is accidental-write isolation, not a
@@ -790,30 +842,9 @@ export async function createScratchWorkspace(
   let copiedOwnerStat: fs.Stats | undefined;
   try {
     if (signal?.aborted) controller.abort(signal.reason);
-    throwIfSetupCancelled(controller.signal, signal);
-    sourceCwd = await fs.promises.realpath(cwd);
-    throwIfSetupCancelled(controller.signal, signal);
-    sourceRoot = await findCopyRoot(sourceCwd, controller.signal);
-    throwIfSetupCancelled(controller.signal, signal);
-    if (!isWithin(sourceRoot, sourceCwd)) {
-      throw new ScratchSetupError(
-        "Scratch workspace could not map the task cwd into its project root.",
-      );
-    }
-
-    // Fast-fail on blockers that are knowable before anything is created:
-    // the same rule the copy validation enforces, run read-only against the
-    // source. A rejection here costs milliseconds instead of a doomed
-    // reflink copy, and no lease/container is left behind. The post-copy
-    // validation below stays the authority — the tree can change mid-copy.
-    await validateScratchTree(
-      sourceRoot,
-      sourceRoot,
-      false,
-      controller.signal,
-      signal,
-    );
-    await assertGitMetadataContained(sourceRoot, controller.signal);
+    const resolved = await resolveScratchSource(cwd, controller.signal, signal);
+    sourceCwd = resolved.sourceCwd;
+    sourceRoot = resolved.sourceRoot;
 
     containerDir = path.join(path.dirname(sourceRoot), SCRATCH_CONTAINER_NAME);
     const uid = process.getuid?.();