one-code-extension 0.4.1 → 0.5.0

package/extensions/workflow/run-manager.ts

@@ -15,6 +15,7 @@ import { randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import { join } from "node:path";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { PermissionBridge } from "../permissions/subagent-gate.ts";
 import type { HookBridge } from "../hooks/subagent-bridge.ts";
 import type { SubagentDefault } from "../subagents/default-model.ts";
@@ -25,7 +26,7 @@ import { AgentRecordStore, previewValue } from "./records.ts";
 import { findSavedWorkflow } from "./saved-workflows.ts";
 import { parseWorkflowScript } from "./script-source.ts";
 import { runWorkflowScript } from "./vm-runtime.ts";
-import type { RunProgressEvent, RunStatus, WorkflowMeta } from "./types.ts";
+import type { AgentRecord, RunProgressEvent, RunStatus, WorkflowMeta } from "./types.ts";
 import { WorkflowScriptError } from "./types.ts";
 import type { ViewerRunSnapshot } from "./viewer.ts";
 
@@ -53,6 +54,10 @@ export interface StartRunOptions {
 	unusableModels?: () => ReadonlySet<string>;
 	/** An agent's provider refused its model: published so every picker skips it (lib/model-unusable.ts). */
 	onModelUnusable?: (model: string, reason: string) => void;
+	/** An agent's edit or write changed a file (lib/child-writes.ts). */
+	onChildWrite?: (path: string, agent: string | undefined) => void;
+	/** The parent's live MCP tools, shared into every workflow agent (see AgentRunnerOptions). */
+	getMcpTools?: () => ToolDefinition[] | Promise<ToolDefinition[]>;
 }
 
 export class RunHandle extends EventEmitter {
@@ -137,9 +142,11 @@ function formatEvent(event: RunProgressEvent): string | undefined {
 			return `— ${event.phase} —`;
 		case "agentStart":
 			return `⏳ ${event.label}${event.phase ? ` [${event.phase}]` : ""}`;
-		case "agentEnd":
-			if (event.text) return `✗ ${event.label}: ${event.text}`;
-			return `✓ ${event.label}${event.replayed ? " (replayed)" : ""}${event.tokens ? ` · ${event.tokens.output} out` : ""}`;
+		case "agentEnd": {
+			const kept = event.worktree ? ` · worktree kept at ${event.worktree.path}` : "";
+			if (event.text) return `✗ ${event.label}: ${event.text}${kept}`;
+			return `✓ ${event.label}${event.replayed ? " (replayed)" : ""}${event.tokens ? ` · ${event.tokens.output} out` : ""}${kept}`;
+		}
 		default:
 			return undefined;
 	}
@@ -254,6 +261,9 @@ export class WorkflowRunManager {
 				onUsage: options.onUsage,
 				unusableModels: options.unusableModels,
 				onModelUnusable: options.onModelUnusable,
+				onChildWrite: options.onChildWrite,
+				getMcpTools: options.getMcpTools,
+				resultsDir: handle.runDir,
 			});
 
 			const { globals, state } = createScriptGlobals({
@@ -342,14 +352,27 @@ export function buildRunReport(handle: RunHandle): string {
 		? `${state.agentCount()} agent(s), ${state.outputTokens()} output tokens, $${state.cost().toFixed(4)}, ${duration}s`
 		: `${duration}s`;
 
+	const kept = keptWorktreesSection(handle.agents.list());
 	if (handle.status === "completed") {
 		const resultText =
 			handle.result === undefined
 				? "(script returned no value)"
 				: previewValue(handle.result, RESULT_CAP, "\n… (truncated)");
-		return `Workflow **${handle.meta.name}** (${handle.runId}) completed — ${statsLine}.\n\nResult:\n${resultText}`;
+		return `Workflow **${handle.meta.name}** (${handle.runId}) completed — ${statsLine}.\n\nResult:\n${resultText}${kept}`;
 	}
 
 	const tail = handle.recentEvents.slice(-5).join("\n");
-	return `Workflow **${handle.meta.name}** (${handle.runId}) ${handle.status} — ${statsLine}.\nReason: ${handle.errorMessage ?? "unknown"}${tail ? `\nRecent progress:\n${tail}` : ""}\nCompleted agent calls are journaled; re-invoke the workflow tool with resumeFromRunId: "${handle.runId}" to continue from where it stopped.`;
+	return `Workflow **${handle.meta.name}** (${handle.runId}) ${handle.status} — ${statsLine}.\nReason: ${handle.errorMessage ?? "unknown"}${tail ? `\nRecent progress:\n${tail}` : ""}\nCompleted agent calls are journaled; re-invoke the workflow tool with resumeFromRunId: "${handle.runId}" to continue from where it stopped.${kept}`;
+}
+
+/**
+ * The report's list of isolation worktrees the run's agents left work in:
+ * their edits and commits live only there, so the model must be told where
+ * to review and merge them. Empty when every worktree was removed.
+ */
+function keptWorktreesSection(agents: readonly AgentRecord[]): string {
+	const kept = agents.filter((agent) => agent.worktree);
+	if (kept.length === 0) return "";
+	const lines = kept.map((agent) => `- ${agent.label}: ${agent.worktree!.path}${agent.worktree!.branch ? ` (branch ${agent.worktree!.branch})` : ""}`);
+	return `\n\nWorktrees kept with agents' changes or commits (review or merge them):\n${lines.join("\n")}`;
 }

package/extensions/workflow/saved-workflows.ts

@@ -10,7 +10,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import { parseWorkflowScript } from "./script-source.ts";
 import type { SavedWorkflow } from "./types.ts";
-import { claudeUserDir } from "../lib/paths.ts";
+import { projectConfigDir, userConfigDir } from "../lib/config-mode.ts";
 
 function scanDir(dir: string, source: SavedWorkflow["source"]): SavedWorkflow[] {
 	if (!existsSync(dir)) return [];
@@ -29,8 +29,9 @@ function scanDir(dir: string, source: SavedWorkflow["source"]): SavedWorkflow[]
 	return found;
 }
 
+/** `.claude/workflows` and `~/.claude/workflows`, or their `.onecode` twins in independent mode (lib/config-mode.ts). */
 export function workflowDirs(cwd: string, home: string): { project: string; user: string } {
-	return { project: join(cwd, ".claude", "workflows"), user: join(claudeUserDir(home), "workflows") };
+	return { project: join(projectConfigDir(cwd), "workflows"), user: join(userConfigDir(home), "workflows") };
 }
 
 export function discoverSavedWorkflows(cwd: string, home: string): SavedWorkflow[] {

package/extensions/workflow/types.ts

@@ -47,8 +47,25 @@ export interface AgentCallResult {
 	value: unknown;
 	tokens: AgentTokens;
 	cost: number;
-	/** Path of a kept worktree (uncommitted changes were left behind), if any. */
+	/** Path of a kept worktree (the agent left uncommitted changes or commits there), if any. */
 	worktreePath?: string;
+	/** The kept worktree's branch, which holds the agent's commits. */
+	worktreeBranch?: string;
+}
+
+/** An `isolation: 'worktree'` agent's worktree, kept because it holds the agent's work. */
+export interface KeptWorktree {
+	path: string;
+	branch?: string;
+}
+
+/**
+ * The worktree a failed agent call kept, carried on the error it threw (the
+ * call returns no result to put it on), so the run still reports it.
+ */
+export function keptWorktreeOf(error: unknown): KeptWorktree | undefined {
+	const kept = (error as { keptWorktree?: KeptWorktree } | undefined)?.keptWorktree;
+	return kept && typeof kept.path === "string" ? kept : undefined;
 }
 
 /** One tool call an agent made, kept structured so the viewer owns the formatting. */
@@ -122,6 +139,8 @@ export type RunProgressEvent = (
 			preview?: string;
 			/** Failure message; presence means the agent failed. */
 			text?: string;
+			/** The agent's isolation worktree, kept because it holds changes or commits. */
+			worktree?: KeptWorktree;
 	  } & AgentEventBase)
 ) & { source?: string };
 
@@ -147,6 +166,8 @@ export interface AgentRecord {
 	outcome?: string;
 	/** Failure message when status === "failed". */
 	error?: string;
+	/** The agent's kept isolation worktree, where its changes or commits wait to be merged. */
+	worktree?: KeptWorktree;
 }
 
 /** A saved workflow discovered in .claude/workflows/ or ~/.claude/workflows/. */

package/extensions/workflow/viewer.ts

@@ -11,9 +11,11 @@
  * before painting so ANSI escapes never enter the width accounting.
  */
 
-import { cutPlainText as cut, formatDuration, padPlainText, splitCell, splitRow, visibleWidth, wrapPlainText } from "../lib/tui-render.ts";
+import { cutPlainText as cut, formatDuration, padPlainText, splitCell, splitRow, visibleWidth, wrapHints, wrapPlainText, wrapProse } from "../lib/tui-render.ts";
 import { formatTokenCount } from "../subagents/usage.ts";
 import type { AgentRecord, RunStatus } from "./types.ts";
+import { keyId, keyText } from "../lib/key-input.ts";
+import { projectConfigDirName } from "../lib/config-mode.ts";
 
 /** Theme access the renderer needs: fg tokens ("accent", "dim", "error", …) and bold. */
 export interface ViewerPaint {
@@ -76,24 +78,30 @@ export type ViewerKey =
 	| { kind: "close" };
 
 export function decodeViewerKey(data: string): ViewerKey | undefined {
-	switch (data) {
-		case "\x1b[A":
-		case "\x1bOA":
+	switch (keyId(data)) {
+		case "up":
 			return { kind: "up" };
-		case "\x1b[B":
-		case "\x1bOB":
+		case "down":
 			return { kind: "down" };
-		case "\x1b[5~":
+		case "pageUp":
 			return { kind: "pageUp" };
-		case "\x1b[6~":
+		case "pageDown":
+		// pi's fullscreen mode keeps PageUp/PageDown for its own scrollback, so
+		// space and b page too (findings §10).
+		case "space":
 			return { kind: "pageDown" };
-		case "\t":
+		case "tab":
 			return { kind: "nextRun" };
-		case "\r":
-		case "\n":
+		case "enter":
 			return { kind: "enter" };
-		case "\x1b":
+		case "escape":
 			return { kind: "back" };
+		case "ctrl+c": // close from anywhere, like q
+			return { kind: "close" };
+		default:
+			break;
+	}
+	switch (keyText(data)) {
 		case "x":
 		case "X":
 			return { kind: "stop" };
@@ -101,8 +109,9 @@ export function decodeViewerKey(data: string): ViewerKey | undefined {
 		case "S":
 			return { kind: "save" };
 		case "q":
-		case "\x03": // ctrl+c — close from anywhere, like q
 			return { kind: "close" };
+		case "b":
+			return { kind: "pageUp" };
 		default:
 			return undefined;
 	}
@@ -137,7 +146,7 @@ export function planSave(input: {
 	sameContent: boolean;
 	confirmed: boolean;
 }): { action: "write" | "confirm" | "noop"; notice: string } {
-	const target = `.claude/workflows/${input.name}.js`;
+	const target = `${projectConfigDirName()}/workflows/${input.name}.js`;
 	if (!input.exists || input.sameContent) return { action: "write", notice: `saved to ${target}` };
 	if (input.confirmed) return { action: "write", notice: `overwrote ${target}` };
 	return { action: "confirm", notice: `${target} exists and differs — press s again to overwrite` };
@@ -348,7 +357,11 @@ export function buildDetail(
 	if (record.status === "failed") {
 		section("Error", wrapPlainText(record.error ?? "unknown", width - 2), "error");
 	} else {
-		section("Outcome", record.outcome ? wrapPlainText(record.outcome, width - 2) : ["Still running…"], record.outcome ? undefined : "dim");
+		section("Outcome", record.outcome ? wrapProse(record.outcome, width - 2) : ["Still running…"], record.outcome ? undefined : "dim");
+	}
+	if (record.worktree) {
+		const { path, branch } = record.worktree;
+		section("Worktree kept", wrapPlainText(`${path}${branch ? ` (branch ${branch})` : ""}`, width - 2));
 	}
 	return lines;
 }
@@ -367,6 +380,20 @@ export interface ViewerInput {
 
 const MIN_TWO_PANE_WIDTH = 70;
 
+/**
+ * Rows the viewer may take. It replaces the editor, so pi's layout keeps the
+ * rest of the dock beside it: the status strip, the permission-mode line and
+ * the footer below, at least one transcript row above, and a status or
+ * widget line. pi cuts a component taller than its share from the bottom,
+ * which took the key-hint row, so the viewer leaves those rows free.
+ * `stripRows` is the status strip's current row count.
+ */
+export function viewerHeight(terminalRows: number, mode: "full" | "half", stripRows: number): number {
+	const reserved = 4 + Math.max(0, stripRows);
+	const available = Math.max(8, terminalRows - reserved);
+	return mode === "half" ? Math.min(available, Math.max(12, Math.min(Math.floor(terminalRows / 2), 30))) : available;
+}
+
 export function renderViewer(input: ViewerInput, paint: ViewerPaint): string[] {
 	const { runs, state } = input;
 	const width = Math.max(20, input.width);
@@ -406,10 +433,18 @@ export function renderViewer(input: ViewerInput, paint: ViewerPaint): string[] {
 		out.push(paint.fg("error", cut(`⚠ ${run.errorMessage}`, width)));
 	}
 
-	// Body: two boxed panes, side by side (or stacked when narrow).
-	const footerRows = 1;
-	const bodyHeight = Math.max(6, input.height - out.length - footerRows);
+	// Footer: per-level key hints, replaced by a transient notice when set. It
+	// wraps at the separators on a narrow terminal so no key is cut off, and
+	// the body gives up the rows the footer needs.
 	const atAgents = state.level === "agents" && phase && phase.agents.length > 0;
+	const stopHint = run.status === "running" ? "x stop workflow · " : "";
+	const hints = !atAgents
+		? `↑↓ select · ⏎ open · ${runs.length > 1 ? "tab run · " : ""}${stopHint}s save · esc close`
+		: `↑↓ agent · ⏎ prompt · space/b scroll · ${stopHint}s save · esc back`;
+	const footer = state.notice ? [cut(state.notice, width)] : wrapHints(hints, width);
+
+	// Body: two boxed panes, side by side (or stacked when narrow).
+	const bodyHeight = Math.max(6, input.height - out.length - footer.length);
 
 	const agentCountTitle = phase
 		? `${phase.title} · ${phase.agents.length} agent${phase.agents.length === 1 ? "" : "s"}`
@@ -458,12 +493,7 @@ export function renderViewer(input: ViewerInput, paint: ViewerPaint): string[] {
 		out.push(...boxPane(rightTitle, panes.right, width, rightHeight, paint));
 	}
 
-	// Footer: per-level key hints, replaced by a transient notice when set.
-	const stopHint = run.status === "running" ? "x stop workflow · " : "";
-	const hints = !atAgents
-		? `↑↓ select · ⏎ open · ${runs.length > 1 ? "tab run · " : ""}${stopHint}s save · esc close`
-		: `↑↓ agent · ⏎ prompt · pgup/pgdn scroll · ${stopHint}s save · esc back`;
-	out.push(paint.fg("dim", cut(state.notice ?? hints, width)));
+	for (const line of footer) out.push(paint.fg("dim", line));
 	return out;
 }
 

package/extensions/workflow/widget.ts

@@ -12,6 +12,7 @@
  */
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { canShowCustomUi } from "../lib/headless-output.ts";
 import { linesComponent, liveUiCtx, safeThemeBold, safeThemePaint } from "../lib/tui-render.ts";
 import type { RunHandle, WorkflowRunManager } from "./run-manager.ts";
 import { MAX_STATUS_ROWS, renderStatusRows, type ViewerRunSnapshot } from "./viewer.ts";
@@ -42,6 +43,8 @@ export class WorkflowWidget {
 	constructor(
 		private readonly manager: WorkflowRunManager,
 		private readonly getCtx: () => ExtensionContext | undefined,
+		/** Told the rows this strip paints below the editor (lib/dock-rows.ts). */
+		private readonly onRows: (rows: number) => void = () => {},
 	) {}
 
 	attach(handle: RunHandle): void {
@@ -64,6 +67,12 @@ export class WorkflowWidget {
 		return Math.min(this.manager.list().length, MAX_STATUS_ROWS);
 	}
 
+	/** Rows the strip paints: one per shown run plus the "+n more" line. */
+	paintedRowCount(): number {
+		const total = this.manager.list().length;
+		return Math.min(total, MAX_STATUS_ROWS) + (total > MAX_STATUS_ROWS ? 1 : 0);
+	}
+
 	selectedRun(): ViewerRunSnapshot | undefined {
 		if (this.focusIndex === undefined) return undefined;
 		return this.manager.snapshots(MAX_STATUS_ROWS)[this.focusIndex];
@@ -99,6 +108,7 @@ export class WorkflowWidget {
 
 	dispose(): void {
 		this.disposed = true;
+		this.onRows(0);
 		if (this.timer) clearTimeout(this.timer);
 		if (this.ticker) clearInterval(this.ticker);
 		this.timer = this.ticker = undefined;
@@ -124,6 +134,7 @@ export class WorkflowWidget {
 		this.syncTicker(runs);
 		if (!runs.length) {
 			ctx.ui.setWidget(WIDGET_KEY, undefined);
+			this.onRows(0);
 			return;
 		}
 		if (this.focusIndex !== undefined && this.focusIndex >= this.rowCount()) {
@@ -131,6 +142,14 @@ export class WorkflowWidget {
 		}
 		const selected = this.focusIndex;
 		const now = Date.now();
+		// RPC forwards string-array widgets but silently ignores factories.
+		if (!canShowCustomUi(ctx)) {
+			const lines = runs.map((run) => `${run.runId} ${run.name} — ${run.status} (${run.agents.length} agents)`);
+			if (totalRuns > runs.length) lines.push(`${totalRuns - runs.length} more workflows — /workflows to list all`);
+			ctx.ui.setWidget(WIDGET_KEY, lines, { placement: "belowEditor" });
+			this.onRows(0); // no TUI view sizes itself in RPC
+			return;
+		}
 		ctx.ui.setWidget(
 			WIDGET_KEY,
 			(tui, theme) => {
@@ -148,6 +167,7 @@ export class WorkflowWidget {
 			},
 			{ placement: "belowEditor" },
 		);
+		this.onRows(this.paintedRowCount());
 	}
 
 	/** Keep elapsed time ticking while any run is live; stop when none is. */

package/extensions/worktree/descriptions.ts

@@ -0,0 +1,91 @@
+/**
+ * enter_worktree and exit_worktree's model-facing texts: Claude Code's
+ * EnterWorktree and ExitWorktree descriptions, trimmed of what One Code does
+ * not have (pure).
+ *
+ * Removed: the WorktreeCreate/WorktreeRemove hooks, the `worktree.baseRef`
+ * setting (a new worktree always branches from the current HEAD), the
+ * prompt on session exit, nested repositories in a multi-repo workspace,
+ * switching from an agent pinned at launch, the tmux session and the cache
+ * clearing on exit. Tool names are One Code's.
+ */
+
+/** Claude Code's EnterWorktree description, naming the mode's config directory (`.onecode` in independent mode, lib/config-mode.ts). */
+export function enterWorktreeDescription(configDir = ".claude"): string {
+	return `Use this tool ONLY when explicitly instructed to work in a worktree — either by the user directly, or by project instructions (CLAUDE.md / memory). This tool creates an isolated git worktree and switches the current session into it.
+
+## When to Use
+
+- The user explicitly says "worktree" (e.g., "start a worktree", "work in a worktree", "create a worktree", "use a worktree")
+- CLAUDE.md or memory instructions direct you to work in a worktree for the current task
+
+## When NOT to Use
+
+- The user asks to create a branch, switch branches, or work on a different branch — use git commands instead
+- The user asks to fix a bug or work on a feature — use normal git workflow unless worktrees are explicitly requested by the user or project instructions
+- Never use this tool unless "worktree" is explicitly mentioned by the user or in CLAUDE.md / memory instructions
+
+## Requirements
+
+- Must be in a git repository
+- Must not already be in a worktree session when creating a new worktree (\`name\`); switching into another existing worktree via \`path\` is allowed
+
+## Behavior
+
+- In a git repository: creates a new git worktree inside \`${configDir}/worktrees/\` on a new branch from your current local HEAD
+- Switches the session's working directory to the new worktree
+- Use exit_worktree to leave the worktree mid-session (keep or remove)
+
+## Entering an existing worktree
+
+Pass \`path\` instead of \`name\` to switch the session into a worktree that already exists (e.g., one you just created with \`git worktree add\`). The path must appear in \`git worktree list\` for the current repository; other paths are rejected. exit_worktree will not remove a worktree entered this way; use \`action: "keep"\` to return to the original directory.
+
+Switching with \`path\` also works when the session is already in a worktree (the previous worktree is left on disk, untouched). Re-issue enter_worktree with \`path\` to return to one.
+
+## Parameters
+
+- \`name\` (optional): A name for a new worktree. If neither \`name\` nor \`path\` is provided, a random name is generated.
+- \`path\` (optional): Path to an existing worktree of the current repository to enter instead of creating one. Mutually exclusive with \`name\`.
+`;
+}
+
+export const ENTER_WORKTREE_DESCRIPTION = enterWorktreeDescription();
+
+export const EXIT_WORKTREE_DESCRIPTION = `Exit a worktree session created by enter_worktree and return the session to the original working directory.
+
+## Scope
+
+This tool ONLY operates on the worktree session enter_worktree started in this session. It will NOT touch:
+- Worktrees you created manually with \`git worktree add\` and never entered with enter_worktree (one entered by \`path\` can be left with \`action: "keep"\`, but never removed)
+- Worktrees from a previous session (even if created by enter_worktree then)
+- The directory you're in if enter_worktree was never called
+
+If called outside an enter_worktree session, the tool is a **no-op**: it reports that no worktree session is active and takes no action. Filesystem state is unchanged.
+
+## When to Use
+
+- The user explicitly asks to "exit the worktree", "leave the worktree", "go back", or otherwise end the worktree session
+- Do NOT call this proactively — only when the user asks
+
+## Parameters
+
+- \`action\` (required): \`"keep"\` or \`"remove"\`
+  - \`"keep"\` — leave the worktree directory and branch intact on disk. Use this if the user wants to come back to the work later, or if there are changes to preserve.
+  - \`"remove"\` — delete the worktree directory and its branch. Use this for a clean exit when the work is done or abandoned.
+- \`discard_changes\` (optional, default false): only meaningful with \`action: "remove"\`. If the worktree has uncommitted files or commits not on the original branch, the tool will REFUSE to remove it unless this is set to \`true\`. If the tool returns an error listing changes, confirm with the user before re-invoking with \`discard_changes: true\`.
+
+## Behavior
+
+- Restores the session's working directory to where it was before enter_worktree
+- Once exited, enter_worktree can be called again to create a fresh worktree
+`;
+
+export const ENTER_WORKTREE_PARAMS = {
+	name: `Optional name for a new worktree. Each "/"-separated segment may contain only letters, digits, dots, underscores, and dashes; max 64 chars total. A random name is generated if not provided. Mutually exclusive with \`path\`.`,
+	path: `Path to an existing worktree to switch into instead of creating a new one. Must appear in \`git worktree list\` for the current repo. Mutually exclusive with \`name\`.`,
+} as const;
+
+export const EXIT_WORKTREE_PARAMS = {
+	action: `"keep" leaves the worktree and branch on disk; "remove" deletes both.`,
+	discard_changes: `Required true when action is "remove" and the worktree has uncommitted files or unmerged commits. The tool will refuse and list them otherwise.`,
+} as const;