@esso0428/pi-subagents 0.17.16 → 0.17.17

package/src/invocation-config.ts

@@ -1,59 +1,5 @@
-import { Type } from "@sinclair/typebox";
 import type { AgentConfig, IsolationMode, JoinMode, ThinkingLevel } from "./types.js";
 
-/**
- * The model-facing `isolation` parameter, shared by the `Agent` tool and the
- * nested delegation tool so the two cannot drift.
- *
- * Shape matters more than wording here. As a single-value optional literal,
- * models that fill every optional parameter — the transcript on #231 shows one
- * emitting `resume: ""`, `schedule: ""` and `model: "default"` alongside it —
- * had only `"worktree"` available to fill it with, and kept spawning worktrees
- * across three turns while their own reasoning said to omit the field. Every
- * other optional parameter has an inert filler; this one did not. `"off"` is
- * listed first and described as the default so the harmless value is the
- * obvious one to reach for.
- *
- * The wording tracks Claude Code's own `isolation` parameter, whose phrasing
- * models have the most exposure to: one description on the union rather than
- * per-value ones, opening "Isolation mode.", then a sentence per value in
- * schema order, each with its caveats in a trailing parenthetical. Two clauses
- * are ours, because our shape is not theirs — `"off"` has no counterpart there
- * (their enum is `worktree | remote`, so both of their values do something),
- * and neither does the uncommitted-work warning, which is the specific trap
- * #231 fell into. Deliberately absent is any "only use a worktree when…"
- * restriction: Claude Code's `Agent` tool states the capability and stops, and
- * a second legal value is what lets a model decline one, not being told to.
- */
-const isolationParamShape = {
-  isolation: Type.Optional(
-    Type.Union([Type.Literal("off"), Type.Literal("worktree")], {
-      description:
-        'Isolation mode. Default "off". "off" runs the agent in the current checkout, the same as omitting the field. "worktree" creates a temporary git worktree so the agent works on an isolated copy of the repo (a copy cannot see uncommitted or staged changes in the main checkout).',
-    }),
-  ),
-};
-
-/**
- * Build the `isolation` parameter for a tool schema, or nothing when the
- * project disabled worktrees (`worktreeIsolation: false`).
- *
- * Dropping the field beats accepting it and quietly downgrading. The setting is
- * for a project whose model passes `"worktree"` on *every* call, so a
- * per-result "isolation was disabled" note would be noise on every result and
- * would keep raising the salience of a capability that isn't there. With no
- * field there is nothing to pass, nothing to drop, and nothing to explain — the
- * same trade `scheduleParam` makes for disabled scheduling, at zero LLM-context
- * cost. The resolver gate and the `agent-manager` check still cover the paths a
- * schema can't reach: agent files, the scheduler, and cross-extension RPC.
- *
- * Like `scheduleParam`, this is read once at tool registration — flipping the
- * setting needs a new pi session for the schema to change.
- */
-export function isolationParam(enabled: boolean): Partial<typeof isolationParamShape> {
-  return enabled ? isolationParamShape : {};
-}
-
 interface AgentInvocationParams {
   model?: string;
   thinking?: string;
@@ -61,42 +7,12 @@ interface AgentInvocationParams {
   run_in_background?: boolean;
   inherit_context?: boolean;
   isolated?: boolean;
-  /**
-   * Untyped on purpose. Both tool schemas now build this field conditionally
-   * and spread it, which erases TypeBox's literal inference to `unknown` (the
-   * `schedule` param has the same shape). The resolver below narrows by
-   * comparison rather than trusting the declaration, which also makes it safe
-   * for the cross-extension RPC path, where options arrive unvalidated.
-   */
-  isolation?: unknown;
-}
-
-interface ResolveOptions {
-  /**
-   * Whether worktree isolation is permitted at all. False when the project set
-   * `worktreeIsolation: false`, which drops a requested worktree rather than
-   * failing the call: the fail-loud precedent covers spawns that *cannot* work,
-   * while this one is the user opting out, and throwing would break exactly the
-   * calls the `"off"` value exists to tolerate. Defaults to allowed.
-   */
-  worktreeAllowed?: boolean;
-  /**
-   * What an unqualified spawn means — neither the call nor the agent file said.
-   *
-   * Top-level callers pass the `backgroundByDefault` setting (default `true`,
-   * following Claude Code). Nested callers pass `false` unconditionally: a
-   * detached child is killed by `abortOwnedChildren` when its parent settles
-   * and has no notification path of its own, so backgrounding one loses its
-   * work. Both call sites pass it explicitly; the `false` fallback only covers
-   * a caller that supplies no options at all, which in-tree means tests.
-   */
-  defaultRunInBackground?: boolean;
+  isolation?: IsolationMode;
 }
 
 export function resolveAgentInvocationConfig(
   agentConfig: AgentConfig | undefined,
   params: AgentInvocationParams,
-  opts?: ResolveOptions,
 ): {
   modelInput?: string;
   modelFromParams: boolean;
@@ -106,47 +22,16 @@ export function resolveAgentInvocationConfig(
   runInBackground: boolean;
   isolated: boolean;
   isolation?: IsolationMode;
-  /**
-   * Caller parameters an agent file's frontmatter outranked, so the surfaces can
-   * say "(asked X)" instead of presenting the effective value as the requested
-   * one (#182). Populated only where both sides named something and they
-   * disagree — a caller who asked for what they got was still honored.
-   *
-   * `max_turns` is deliberately absent: no surface renders a requested-vs-
-   * effective turn limit, so recording one would be dead data.
-   */
-  overridden?: { thinking?: ThinkingLevel; model?: string };
 } {
-  // Precedence first, collapse second — reversing these loses the veto, since
-  // an agent file's "off" only outranks a caller's "worktree" while it is still
-  // a value. Everything downstream then sees "worktree" or nothing at all.
-  const requested = agentConfig?.isolation ?? params.isolation;
-  const isolation = requested === "worktree" && opts?.worktreeAllowed !== false ? "worktree" : undefined;
-
-  const overriddenThinking = agentConfig?.thinking != null && params.thinking != null
-    && agentConfig.thinking !== params.thinking
-    ? params.thinking as ThinkingLevel
-    : undefined;
-  const overriddenModel = agentConfig?.model != null && params.model != null
-    && agentConfig.model !== params.model
-    ? params.model
-    : undefined;
-
   return {
     modelInput: agentConfig?.model ?? params.model,
     modelFromParams: agentConfig?.model == null && params.model != null,
     thinking: (agentConfig?.thinking ?? params.thinking) as ThinkingLevel | undefined,
     maxTurns: agentConfig?.maxTurns ?? params.max_turns,
     inheritContext: agentConfig?.inheritContext ?? params.inherit_context ?? false,
-    runInBackground: agentConfig?.runInBackground ?? params.run_in_background ?? opts?.defaultRunInBackground ?? false,
+    runInBackground: agentConfig?.runInBackground ?? params.run_in_background ?? false,
     isolated: agentConfig?.isolated ?? params.isolated ?? false,
-    isolation,
-    // Undefined rather than an empty object when nothing was overridden: callers
-    // spread this into the invocation snapshot, and an always-present key would
-    // put `requestedThinking: undefined` on every record.
-    overridden: overriddenThinking || overriddenModel
-      ? { thinking: overriddenThinking, model: overriddenModel }
-      : undefined,
+    isolation: agentConfig?.isolation ?? params.isolation,
   };
 }
 

package/src/model-resolver.ts

@@ -14,24 +14,6 @@ export interface ModelRegistry {
   getAvailable?(): any[];
 }
 
-/**
- * Both display forms of a model. The short one goes on tight rows (the widget,
- * the Agent tool result), the canonical one where there is room to disambiguate
- * two providers serving a similarly-named model (the conversation viewer).
- *
- * One function, because `index.ts` labels the model it resolved before the run
- * and `agent-manager.ts` relabels it from the live session afterwards — the two
- * must agree or the label would visibly change the moment the session starts.
- */
-export function describeModel(
-  model: { provider: string; id: string; name?: string },
-): { modelName: string; modelId: string } {
-  return {
-    modelName: (model.name ?? model.id).replace(/^Claude\s+/i, "").toLowerCase(),
-    modelId: `${model.provider}/${model.id}`,
-  };
-}
-
 /**
  * Resolve a model string to a Model instance.
  * Tries exact match first ("provider/modelId"), then fuzzy match against all available models.

package/src/output-file.ts

@@ -10,20 +10,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { AgentSession, AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 
-/**
- * Project/global default for writing a subagent's `.output` transcript; a custom
- * agent's `output_transcript` overrides it per agent.
- *
- * State lives here rather than in an index.ts closure because both spawn paths
- * need it — the top-level Agent tool and the nested delegation tools. Same
- * reason `scopeModels` lives in model-scope.ts: a setting only one path can read
- * is a setting the other path silently ignores.
- */
-let outputTranscriptDefault = true;
-
-export function getOutputTranscriptDefault(): boolean { return outputTranscriptDefault; }
-export function setOutputTranscriptDefault(b: boolean): void { outputTranscriptDefault = b; }
-
 /**
  * Encode a cwd path as a filesystem-safe directory name. Handles:
  *   - POSIX:   "/home/user/project"        → "home-user-project"
@@ -37,14 +23,9 @@ export function encodeCwd(cwd: string): string {
     .replace(/^-+/, "");           // strip leading dashes (POSIX root, UNC)
 }
 
-/**
- * The per-session scratch directory, created if missing.
- * Mirrors Claude Code's layout: /tmp/{prefix}-{uid}/{encoded-cwd}/{sessionId}/tasks
- *
- * Shared with the workflow tool, which persists each invocation's script here so
- * iterating on one is edit-file-then-rerun — the same convention, one directory.
- */
-export function sessionTaskDir(cwd: string, sessionId: string): string {
+/** Create the output file path, ensuring the directory exists.
+ *  Mirrors Claude Code's layout: /tmp/{prefix}-{uid}/{encoded-cwd}/{sessionId}/tasks/{agentId}.output */
+export function createOutputFilePath(cwd: string, agentId: string, sessionId: string): string {
   const encoded = encodeCwd(cwd);
   const root = join(tmpdir(), `pi-subagents-${process.getuid?.() ?? 0}`);
   mkdirSync(root, { recursive: true, mode: 0o700 });
@@ -57,27 +38,7 @@ export function sessionTaskDir(cwd: string, sessionId: string): string {
   }
   const dir = join(root, encoded, sessionId, "tasks");
   mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-/** Create the output file path, ensuring the directory exists. */
-export function createOutputFilePath(cwd: string, agentId: string, sessionId: string): string {
-  return join(sessionTaskDir(cwd, sessionId), `${agentId}.output`);
-}
-
-/**
- * Ensure a transcript file exists without disturbing what is already in it.
- *
- * A resume reuses the agent's existing transcript (same deterministic path), so
- * it must never call `writeInitialEntry` — that truncates, discarding turns the
- * completion notification still points the user at, and any history the session
- * has since compacted away is gone for good. Appending nothing creates the file
- * when this is the agent's first transcript and is a no-op when it is not.
- */
-export function ensureOutputFile(path: string): void {
-  try {
-    appendFileSync(path, "", "utf-8");
-  } catch { /* ignore — streaming writes are best-effort too */ }
+  return join(dir, `${agentId}.output`);
 }
 
 /** Write the initial user prompt entry. */
@@ -102,24 +63,9 @@ export function streamToOutputFile(
   path: string,
   agentId: string,
   cwd: string,
-  startIndexOrHistoryPath?: number | string,
   historyPath?: string,
 ): () => void {
-  // Keep the fork's historical five-argument form (historyPath as the fifth
-  // argument) while accepting upstream's six-argument resume form
-  // (startIndex, historyPath). This matters because scheduler/RPC/workflow
-  // callers use the ordinary spawn form, whereas resume starts after an
-  // existing in-memory message prefix.
-  const startIndex = typeof startIndexOrHistoryPath === "number" ? startIndexOrHistoryPath : undefined;
-  const durableHistoryPath = typeof startIndexOrHistoryPath === "string"
-    ? startIndexOrHistoryPath
-    : historyPath;
-  // Index of the first message this stream is responsible for. A spawn writes
-  // messages[0] as the initial prompt entry, so it starts at 1. A resume hands
-  // in the session's length as of just before the run: the session already
-  // holds every prior turn, and re-emitting those would duplicate history that
-  // is already in the file.
-  let writtenCount = startIndex ?? 1;
+  let writtenCount = 1; // initial user prompt already written
 
   const flush = () => {
     const messages = session.messages;
@@ -134,8 +80,7 @@ export function streamToOutputFile(
         cwd,
       };
       const entryJson = JSON.stringify(entry) + "\n";
-      const targets = durableHistoryPath && durableHistoryPath !== path ? [path, durableHistoryPath] : [path];
-      for (const target of targets) {
+      for (const target of historyPath && historyPath !== path ? [path, historyPath] : [path]) {
         try {
           appendFileSync(target, entryJson, "utf-8");
         } catch { /* ignore write errors */ }

package/src/prompts.ts

@@ -10,29 +10,6 @@ export interface PromptExtras {
   memoryBlock?: string;
   /** Preloaded skill contents to inject. */
   skillBlocks?: { name: string; content: string }[];
-  /**
-   * Parent directory the worktree copy was created from. Set only for
-   * `isolation: "worktree"` spawns — triggers the block that tells the agent
-   * to stay in the copy.
-   */
-  worktreeBase?: string;
-  /**
-   * Set only for a workflow's own children, and only when they have no
-   * `StructuredOutput` tool to answer through.
-   *
-   * A workflow child's final text is not read by a human — it is the value
-   * `agent()` resolves to, and the script interpolates it straight into the
-   * next stage's prompt. Without this, children answer the way every other
-   * subagent does (a report addressed to a reader), and the padding becomes
-   * input tokens for the stage downstream. Claude Code's `Workflow` tool
-   * documents this contract to the script-writing model; this is the end of it
-   * that makes the documentation true.
-   *
-   * Deliberately NOT applied to every subagent. In pi an ordinary agent's
-   * output IS read by a human — through the Agents widget, the conversation
-   * viewer and `get_subagent_result` — so terse raw data would be wrong there.
-   */
-  workflowChild?: boolean;
 }
 
 /**
@@ -66,26 +43,6 @@ Working directory: ${cwd}
 ${env.isGitRepo ? `Git repository: yes\nBranch: ${env.branch}` : "Not a git repository"}
 Platform: ${env.platform}`;
 
-  // A worktree agent is told its cwd twice: by the env block above (the copy)
-  // and by whatever names the main checkout — the inherited parent prompt in
-  // append mode, or the task prompt in either mode. It follows the latter and
-  // works in the shared tree (#187), so resolve the contradiction explicitly.
-  const worktreeBlock = extras?.worktreeBase
-    ? `\n\n<worktree_isolation>
-Your working directory is an isolated git worktree copy of ${extras.worktreeBase}.
-Work only inside it — never in ${extras.worktreeBase}, even if other instructions name that path as your working directory.
-</worktree_isolation>`
-    : "";
-
-  // The script, not a person, reads what this child returns — see
-  // `PromptExtras.workflowChild` for why only workflow children get this.
-  const workflowBlock = extras?.workflowChild
-    ? `\n\n<workflow_child>
-Your final message IS the return value of this task. A workflow script captures it and passes it to the next stage; no person reads it.
-Return only the answer, in exactly the shape the prompt asks for — no preamble, no summary of what you did, no offer to continue.
-</workflow_child>`
-    : "";
-
   // Build optional extras suffix
   const extraSections: string[] = [];
   if (extras?.memoryBlock) {
@@ -123,7 +80,7 @@ You are operating as a sub-agent invoked to handle a specific task.
     // placed verbatim (no wrapper tag) so it forms an identical byte prefix
     // with the parent session, maximising KV cache hits. The <active_agent>
     // tag and env block vary per call and are placed after the cached prefix.
-    return identity + "\n\n" + bridge + "\n\n" + activeAgentTag + envBlock + worktreeBlock + workflowBlock + customSection + extrasSuffix;
+    return identity + "\n\n" + bridge + "\n\n" + activeAgentTag + envBlock + customSection + extrasSuffix;
   }
 
   // "replace" mode — env header + the config's full system prompt
@@ -132,7 +89,7 @@ You have been invoked to handle a specific task autonomously.
 
 ${envBlock}`;
 
-  return activeAgentTag + replaceHeader + worktreeBlock + workflowBlock + "\n\n" + config.systemPrompt + extrasSuffix;
+  return activeAgentTag + replaceHeader + "\n\n" + config.systemPrompt + extrasSuffix;
 }
 
 /** Fallback base prompt when parent system prompt is unavailable in append mode. */

package/src/schedule.ts

@@ -19,8 +19,6 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Cron } from "croner";
 import { nanoid } from "nanoid";
 import type { AgentManager } from "./agent-manager.js";
-import { normalizeMaxTurns } from "./agent-runner.js";
-import { resolveSpawnType } from "./agent-types.js";
 import { resolveModel } from "./model-resolver.js";
 import type { ScheduleStore } from "./schedule-store.js";
 import type { IsolationMode, ScheduledSubagent, SubagentType, ThinkingLevel } from "./types.js";
@@ -240,15 +238,7 @@ export class SubagentScheduler {
 
     let agentId: string;
     try {
-      // Re-resolve at fire time against the registry as it stands. This does not
-      // reload from disk (the scheduler has no reason to rebuild process-global
-      // state from a timer), so it catches changes that went through /agents or
-      // an Agent call — not a file deleted directly from a shell. The catch below turns
-      // this into lastStatus: "error" plus an error event, like any other
-      // fire-time failure.
-      const dispatch = resolveSpawnType(job.subagent_type);
-      if (!dispatch.ok) throw new Error(dispatch.message);
-      agentId = manager.spawn(pi, ctx, dispatch.type, job.prompt, {
+      agentId = manager.spawn(pi, ctx, job.subagent_type, job.prompt, {
         description: job.description,
         isBackground: true,
         bypassQueue: true,
@@ -257,20 +247,6 @@ export class SubagentScheduler {
         isolated: job.isolated,
         thinkingLevel: job.thinking,
         isolation: job.isolation,
-        // A scheduled run has no tool call to build this, so without it the
-        // conversation viewer shows nothing about how the job was configured.
-        // The model is left out on purpose: agent-manager fills in the effective
-        // one when the session reports it, and naming the pre-session pick here
-        // would only be right until then.
-        invocation: {
-          thinking: job.thinking,
-          // Normalized like the Agent tool's own snapshot: `0` means unlimited,
-          // and rendering it as "max turns: 0" would read as a limit of none.
-          maxTurns: normalizeMaxTurns(job.max_turns),
-          isolated: job.isolated,
-          runInBackground: true,
-          isolation: job.isolation,
-        },
       });
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);
@@ -281,6 +257,7 @@ export class SubagentScheduler {
 
     this.emit({ type: "fired", jobId: id, agentId, name: job.name });
 
+    const record = manager.getRecord(agentId);
     const finalize = (status: "success" | "error") => {
       const next = this.getNextRun(id);
       const current = store.get(id);
@@ -295,16 +272,18 @@ export class SubagentScheduler {
     // AgentManager's promise resolves either way (its .catch returns ""), so we
     // can't infer success/failure from the promise — read record.status instead.
     // Terminal states: completed/steered = success; error/aborted/stopped = error.
-    // awaitStartup first: with isolation: "worktree" the run promise only exists
-    // once the repo copy is made, and a failed copy rejects here.
-    manager.awaitStartup(agentId)
-      .then(() => manager.getRecord(agentId)?.promise)
-      .then(() => {
-        const r = manager.getRecord(agentId);
-        const failed = r?.status === "error" || r?.status === "aborted" || r?.status === "stopped";
-        finalize(failed ? "error" : "success");
-      })
-      .catch(() => finalize("error"));
+    if (record?.promise) {
+      record.promise
+        .then(() => {
+          const r = manager.getRecord(agentId);
+          const failed = r?.status === "error" || r?.status === "aborted" || r?.status === "stopped";
+          finalize(failed ? "error" : "success");
+        })
+        .catch(() => finalize("error"));
+    } else {
+      // Spawn returned without a promise (defensive — bypassQueue path always sets one).
+      finalize("success");
+    }
   }
 
   private emit(event: ScheduleChangeEvent): void {