@cmetech/otto 1.1.0 → 1.2.4

package/src/resources/extensions/subagent/index.ts

@@ -44,6 +44,7 @@ import {
 	buildSubagentProcessArgs,
 	createSubagentLaunchPlan,
 	isSubagentChildProcess,
+	mintSubagentScratchpadName,
 	type SubagentContextMode,
 	type SubagentSessionArgs,
 } from "./launch.js";
@@ -208,6 +209,7 @@ interface UsageStats {
 interface SingleResult {
 	agent: string;
 	trackingName?: string;
+	scratchpadName?: string;
 	agentSource: "user" | "project" | "unknown";
 	task: string;
 	exitCode: number;
@@ -359,6 +361,7 @@ function resultToChildArtifact(result: SingleResult, index: number, cwd?: string
 		index,
 		agent: result.agent,
 		trackingName: result.trackingName,
+		scratchpadName: result.scratchpadName,
 		task: result.task,
 		status: running ? "running" : resultStatus(result),
 		exitCode: result.exitCode,
@@ -486,6 +489,8 @@ async function runSingleAgent(
 			tmpPromptDir = tmp.dir;
 			tmpPromptPath = tmp.filePath;
 		}
+		const scratchpadName = mintSubagentScratchpadName(agent.name);
+		currentResult.scratchpadName = scratchpadName;
 		const launch = createSubagentLaunchPlan({
 			agent,
 			task,
@@ -496,6 +501,7 @@ async function runSingleAgent(
 			session: sessionOverride,
 			cwd,
 			defaultCwd,
+			scratchpadName,
 		});
 		if (launch.session.mode === "fork") currentResult.sessionFile = launch.session.sessionFile;
 		let wasAborted = false;
@@ -638,6 +644,8 @@ async function runSingleAgentInCmuxSplit(
 
 		const bundledPaths = ((process.env.OTTO_BUNDLED_EXTENSION_PATHS ?? process.env.OTTO_BUNDLED_EXTENSION_PATHS) ?? "").split(path.delimiter).map((s) => s.trim()).filter(Boolean);
 		const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
+		const scratchpadName = mintSubagentScratchpadName(agent.name);
+		currentResult.scratchpadName = scratchpadName;
 		const launch = createSubagentLaunchPlan({
 			agent,
 			task,
@@ -648,6 +656,7 @@ async function runSingleAgentInCmuxSplit(
 			session: sessionOverride,
 			cwd,
 			defaultCwd,
+			scratchpadName,
 		});
 		if (launch.session.mode === "fork") currentResult.sessionFile = launch.session.sessionFile;
 		const processArgs = [(process.env.OTTO_BIN_PATH ?? process.env.OTTO_BIN_PATH)!, ...extensionArgs, ...launch.args];

package/src/resources/extensions/subagent/launch.test.ts

@@ -0,0 +1,97 @@
+// src/resources/extensions/subagent/launch.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  buildShellEnvAssignments,
+  buildSubagentProcessEnv,
+  createSubagentLaunchPlan,
+  mintSubagentScratchpadName,
+  SUBAGENT_CHILD_ENV_VAR,
+  SUBAGENT_SCRATCHPAD_ENV_VAR,
+} from './launch.js';
+import type { AgentConfig } from './agents.js';
+
+const STUB_AGENT: AgentConfig = {
+  name: 'rca-analyst',
+  description: '',
+  systemPrompt: 'x',
+  source: 'project',
+  filePath: '/tmp/rca-analyst.md',
+};
+
+describe('mintSubagentScratchpadName', () => {
+  it('produces subagent-<agent>-<6hex> for simple input', () => {
+    const name = mintSubagentScratchpadName('rca-analyst');
+    assert.match(name, /^subagent-rca-analyst-[0-9a-f]{6}$/);
+  });
+  it('sanitizes uppercase + punctuation to kebab', () => {
+    const name = mintSubagentScratchpadName('UPPER & weird!! chars');
+    assert.match(name, /^subagent-upper-weird-chars-[0-9a-f]{6}$/);
+  });
+  it('falls back to subagent-<hex> for empty input', () => {
+    const name = mintSubagentScratchpadName('');
+    assert.match(name, /^subagent-[0-9a-f]{6}$/);
+  });
+  it('truncates agent portion to fit reasonable length', () => {
+    const long = 'a'.repeat(100);
+    const name = mintSubagentScratchpadName(long);
+    // subagent- (9) + max 32 chars agent + - + 6 hex = max 48
+    assert.ok(name.length <= 48);
+    assert.match(name, /^subagent-a+-[0-9a-f]{6}$/);
+  });
+  it('strips diacritics', () => {
+    const name = mintSubagentScratchpadName('résumé');
+    assert.match(name, /^subagent-resume-[0-9a-f]{6}$/);
+  });
+});
+
+describe('buildSubagentProcessEnv', () => {
+  it('without scratchpad name preserves existing OTTO_SUBAGENT_CHILD only', () => {
+    const env = buildSubagentProcessEnv({ FOO: 'bar' });
+    assert.equal(env[SUBAGENT_CHILD_ENV_VAR], '1');
+    assert.equal(env.FOO, 'bar');
+    assert.equal(env[SUBAGENT_SCRATCHPAD_ENV_VAR], undefined);
+  });
+  it('with scratchpad name injects OTTO_SUBAGENT_SCRATCHPAD', () => {
+    const env = buildSubagentProcessEnv({ FOO: 'bar' }, 'subagent-foo-abc123');
+    assert.equal(env[SUBAGENT_CHILD_ENV_VAR], '1');
+    assert.equal(env[SUBAGENT_SCRATCHPAD_ENV_VAR], 'subagent-foo-abc123');
+  });
+});
+
+describe('buildShellEnvAssignments', () => {
+  it('includes scratchpad assignment when var is set', () => {
+    const out = buildShellEnvAssignments({
+      [SUBAGENT_CHILD_ENV_VAR]: '1',
+      [SUBAGENT_SCRATCHPAD_ENV_VAR]: 'subagent-foo-abc123',
+    });
+    assert.ok(out.some((s) => s.startsWith(`${SUBAGENT_CHILD_ENV_VAR}=`)));
+    assert.ok(out.some((s) => s.startsWith(`${SUBAGENT_SCRATCHPAD_ENV_VAR}=`)));
+  });
+  it('omits scratchpad assignment when var is unset', () => {
+    const out = buildShellEnvAssignments({ [SUBAGENT_CHILD_ENV_VAR]: '1' });
+    assert.equal(out.some((s) => s.startsWith(`${SUBAGENT_SCRATCHPAD_ENV_VAR}=`)), false);
+  });
+});
+
+describe('createSubagentLaunchPlan', () => {
+  it('threads scratchpadName into env', () => {
+    const plan = createSubagentLaunchPlan({
+      agent: STUB_AGENT,
+      task: 'do thing',
+      tmpPromptPath: null,
+      defaultCwd: '/tmp',
+      scratchpadName: 'subagent-rca-analyst-abc123',
+    });
+    assert.equal(plan.env[SUBAGENT_SCRATCHPAD_ENV_VAR], 'subagent-rca-analyst-abc123');
+  });
+  it('without scratchpadName leaves env var unset', () => {
+    const plan = createSubagentLaunchPlan({
+      agent: STUB_AGENT,
+      task: 'do thing',
+      tmpPromptPath: null,
+      defaultCwd: '/tmp',
+    });
+    assert.equal(plan.env[SUBAGENT_SCRATCHPAD_ENV_VAR], undefined);
+  });
+});

package/src/resources/extensions/subagent/launch.ts

@@ -1,5 +1,6 @@
 // OTTO + Subagent launch contract and child process safety helpers.
 
+import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { SessionManager } from "@otto/pi-coding-agent";
@@ -7,6 +8,26 @@ import type { AgentConfig } from "./agents.js";
 
 export const SUBAGENT_CHILD_ENV_VAR = "OTTO_SUBAGENT_CHILD";
 export const SUBAGENT_CHILD_ENV_VALUE = "1";
+export const SUBAGENT_SCRATCHPAD_ENV_VAR = "OTTO_SUBAGENT_SCRATCHPAD";
+
+const MAX_SCRATCHPAD_AGENT_PART = 32;
+
+export function mintSubagentScratchpadName(agentName: string): string {
+	const hex = crypto.randomBytes(3).toString("hex");
+	// Sanitize: NFKD + strip combining marks + lowercase + non-[a-z0-9] → '-' + collapse + trim.
+	let sanitized = agentName
+		.normalize("NFKD")
+		.replace(/[̀-ͯ]/g, "")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/-+/g, "-")
+		.replace(/^-+|-+$/g, "");
+	if (sanitized.length > MAX_SCRATCHPAD_AGENT_PART) {
+		sanitized = sanitized.slice(0, MAX_SCRATCHPAD_AGENT_PART).replace(/-+$/, "");
+	}
+	if (!sanitized) return `subagent-${hex}`;
+	return `subagent-${sanitized}-${hex}`;
+}
 
 export type SubagentContextMode = "fresh" | "fork";
 
@@ -30,6 +51,7 @@ export interface SubagentLaunchInput {
 	session?: SubagentSessionArgs;
 	cwd?: string;
 	defaultCwd: string;
+	scratchpadName?: string;
 }
 
 export interface SubagentLaunchPlan {
@@ -43,16 +65,31 @@ export function isSubagentChildProcess(env: NodeJS.ProcessEnv = process.env): bo
 	return env[SUBAGENT_CHILD_ENV_VAR] === SUBAGENT_CHILD_ENV_VALUE;
 }
 
-export function buildSubagentProcessEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
-	return {
+export function buildSubagentProcessEnv(
+	env: NodeJS.ProcessEnv = process.env,
+	scratchpadName?: string,
+): NodeJS.ProcessEnv {
+	const next: NodeJS.ProcessEnv = {
 		...env,
 		[SUBAGENT_CHILD_ENV_VAR]: SUBAGENT_CHILD_ENV_VALUE,
 	};
+	if (scratchpadName) {
+		next[SUBAGENT_SCRATCHPAD_ENV_VAR] = scratchpadName;
+	}
+	return next;
 }
 
 export function buildShellEnvAssignments(env: NodeJS.ProcessEnv = process.env): string[] {
-	const value = env[SUBAGENT_CHILD_ENV_VAR];
-	return value ? [`${SUBAGENT_CHILD_ENV_VAR}=${JSON.stringify(value)}`] : [];
+	const out: string[] = [];
+	const childValue = env[SUBAGENT_CHILD_ENV_VAR];
+	if (childValue) {
+		out.push(`${SUBAGENT_CHILD_ENV_VAR}=${JSON.stringify(childValue)}`);
+	}
+	const scratchpadValue = env[SUBAGENT_SCRATCHPAD_ENV_VAR];
+	if (scratchpadValue) {
+		out.push(`${SUBAGENT_SCRATCHPAD_ENV_VAR}=${JSON.stringify(scratchpadValue)}`);
+	}
+	return out;
 }
 
 export function buildSubagentProcessArgs(
@@ -124,7 +161,7 @@ export function createSubagentLaunchPlan(input: SubagentLaunchInput): SubagentLa
 			input.modelOverride,
 			session,
 		),
-		env: buildSubagentProcessEnv(),
+		env: buildSubagentProcessEnv(process.env, input.scratchpadName),
 		cwd: input.cwd ?? input.defaultCwd,
 		session,
 	};

package/src/resources/extensions/subagent/run-store.ts

@@ -12,6 +12,7 @@ export interface SubagentChildArtifact {
 	index: number;
 	agent: string;
 	trackingName?: string;
+	scratchpadName?: string;
 	task: string;
 	status: SubagentRunStatus;
 	exitCode?: number;
@@ -186,7 +187,7 @@ export function createInitialRunRecord(input: {
 	mode: SubagentRunMode;
 	contextMode: "fresh" | "fork";
 	cwd: string;
-	children: Array<{ agent: string; trackingName?: string; task: string; cwd?: string }>;
+	children: Array<{ agent: string; trackingName?: string; scratchpadName?: string; task: string; cwd?: string }>;
 	now?: string;
 }): SubagentRunRecord {
 	const now = input.now ?? new Date().toISOString();
@@ -203,6 +204,7 @@ export function createInitialRunRecord(input: {
 			index,
 			agent: child.agent,
 			trackingName: child.trackingName,
+			scratchpadName: child.scratchpadName,
 			task: child.task,
 			cwd: child.cwd,
 			status: "queued",

package/src/resources/extensions/workflow/bootstrap/register-extension.ts

@@ -23,6 +23,7 @@ import { logWarning } from "../workflow-logger.js";
 // session hook calling startAuto) would be silently dropped because Node's
 // EventEmitter does not buffer events for late subscribers.
 import { initCmuxEventListeners } from "../../cmux/index.js";
+import { registerPersonaCommands } from "../persona-status.js";
 import { BRAND } from "../strings.js";
 
 export { writeCrashLog } from "./crash-log.js";
@@ -126,6 +127,7 @@ export function registerWorkflowExtension(pi: ExtensionAPI): void {
     ["memory-tools", () => registerMemoryTools(pi)],
     ["exec-tools", () => registerExecTools(pi)],
     ["schedule-wakeup-tool", () => registerScheduleWakeupTool(pi)],
+    ["persona-commands", () => registerPersonaCommands(pi)],
     ["shortcuts", () => registerShortcuts(pi)],
     // cmux is a library (no pi), so gsd sets up the event listeners on its
     // behalf using the shared event channel contract. Registration is

package/src/resources/extensions/workflow/bootstrap/register-hooks.ts

@@ -357,6 +357,15 @@ async function resetAskUserQuestionsTurnCache(): Promise<void> {
   resetAskUserQuestionsCache();
 }
 
+async function initPersonaStatusChip(ctx: ExtensionContext): Promise<void> {
+  try {
+    const { initPersonaWidget } = await import("../persona-status.js");
+    await initPersonaWidget(ctx);
+  } catch {
+    // Non-fatal: persona chip simply won't render if the registry is unavailable.
+  }
+}
+
 async function syncServiceTierStatus(ctx: ExtensionContext): Promise<void> {
   const { getEffectiveServiceTier, formatServiceTierFooterStatus } = await import("../service-tier.js");
   ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
@@ -498,6 +507,7 @@ export function registerHooks(
     approvalQuestionAbortInFlight = false;
     clearDeferredApprovalGate();
     await resetAskUserQuestionsTurnCache();
+    await initPersonaStatusChip(ctx);
     await syncServiceTierStatus(ctx);
     await applyDisabledModelProviderPolicy(ctx);
     await applyCompactionThresholdOverride(ctx);

package/src/resources/extensions/workflow/persona-status.ts

@@ -0,0 +1,109 @@
+// Wires /persona slash commands + the persona status-bar chip into Otto.
+// Spec §2.5 + §5.2. Lives inside the src/resources extension boundary, so it
+// imports only the @otto/coworker-persona package (never src/ modules).
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+} from "@otto/pi-coding-agent";
+import {
+  PersonaRegistry,
+  type PersonaManifest,
+  handleList,
+  handleCurrent,
+  handleSwitch,
+  handleReset,
+  handleInstall,
+  handleUninstall,
+} from "@otto/coworker-persona";
+
+// Sorts ahead of alphabetic extension status keys so the chip lands leftmost
+// in the footer's extension-status block.
+const STATUS_KEY = "00-persona";
+
+const SUBCOMMANDS = ["list", "current", "switch", "install", "uninstall", "reset"] as const;
+
+function ottoHome(): string {
+  return process.env.OTTO_HOME || join(homedir(), ".otto");
+}
+
+function getRegistry(): PersonaRegistry {
+  return new PersonaRegistry({ ottoHome: ottoHome() });
+}
+
+function formatPersonaChip(persona: PersonaManifest): string {
+  const { icon, label } = persona.status_line;
+  return `${icon} ${label}`.trim();
+}
+
+async function refreshPersonaChip(ctx: ExtensionContext, registry: PersonaRegistry): Promise<void> {
+  if (!ctx.hasUI) return;
+  try {
+    const active = await registry.activeInWorkspace(ctx.cwd);
+    ctx.ui.setStatus(STATUS_KEY, formatPersonaChip(active));
+  } catch {
+    ctx.ui.setStatus(STATUS_KEY, undefined);
+  }
+}
+
+// Called on session_start to seed the default persona and render the chip.
+export async function initPersonaWidget(ctx: ExtensionContext): Promise<void> {
+  const registry = getRegistry();
+  try {
+    await registry.ensureDefaultInstalled();
+  } catch {
+    // Non-fatal: chip simply won't render if the default can't be installed.
+  }
+  await refreshPersonaChip(ctx, registry);
+}
+
+export function registerPersonaCommands(pi: ExtensionAPI): void {
+  pi.registerCommand("persona", {
+    description: "Manage Otto co-worker personas (list, current, switch, install, uninstall, reset)",
+    getArgumentCompletions: (prefix: string) =>
+      SUBCOMMANDS.filter((s) => s.startsWith(prefix)).map((s) => ({ value: s, label: s })),
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const registry = getRegistry();
+      await registry.ensureDefaultInstalled();
+      const [sub, ...rest] = args.trim().split(/\s+/).filter(Boolean);
+      const ws = ctx.cwd;
+      try {
+        let lines: string[];
+        switch (sub ?? "current") {
+          case "list":
+            lines = await handleList(registry, ws);
+            break;
+          case "current":
+            lines = await handleCurrent(registry, ws);
+            break;
+          case "switch":
+            lines = await handleSwitch(registry, ws, rest[0]);
+            await refreshPersonaChip(ctx, registry);
+            break;
+          case "reset":
+            lines = await handleReset(registry, ws);
+            await refreshPersonaChip(ctx, registry);
+            break;
+          case "install":
+            lines = await handleInstall(registry, rest[0]);
+            break;
+          case "uninstall":
+            lines = await handleUninstall(registry, rest[0], [ws]);
+            await refreshPersonaChip(ctx, registry);
+            break;
+          default:
+            ctx.ui.notify(
+              `Unknown subcommand: ${sub}. Try: ${SUBCOMMANDS.join(", ")}`,
+              "warning",
+            );
+            return;
+        }
+        ctx.ui.notify(lines.join("\n"), "info");
+      } catch (err) {
+        ctx.ui.notify(err instanceof Error ? err.message : String(err), "error");
+      }
+    },
+  });
+}

package/src/resources/extensions/workflow/tests/auto-recovery.test.ts

@@ -16,6 +16,40 @@ import { invalidateAllCaches } from "../cache.ts";
 import { deriveState, invalidateStateCache } from "../state.ts";
 import { writeIntegrationBranch } from "../git-service.ts";
 
+// Hermetic git environment for the whole test process.
+//
+// These tests create throwaway repos and run tight add/commit loops (some 200+
+// commits). Git's background auto-maintenance (detached `gc --auto`) would fire
+// mid-loop and repack/prune loose objects while the next `git add`/`commit` is
+// still referencing them, producing intermittent, load-dependent failures like
+// "error: invalid object … / Error building trees" or "unable to create
+// temporary file … / failed to write commit object" under a busy `npm test`.
+// Disabling gc/maintenance is the actual fix; isolating global/system config and
+// pinning identity/signing is defense-in-depth so the suite never depends on (or
+// is perturbed by) the developer's git setup.
+{
+  const gitConfig: Array<[string, string]> = [
+    ["user.name", "OTTO Test"],
+    ["user.email", "test@otto.invalid"],
+    ["commit.gpgsign", "false"],
+    ["tag.gpgsign", "false"],
+    ["gc.auto", "0"],
+    ["gc.autoDetach", "false"],
+    ["maintenance.auto", "false"],
+    ["core.hooksPath", "/dev/null"],
+    ["core.fsmonitor", "false"],
+  ];
+  process.env.GIT_CONFIG_GLOBAL = "/dev/null";
+  process.env.GIT_CONFIG_SYSTEM = "/dev/null";
+  process.env.GIT_CONFIG_NOSYSTEM = "1";
+  process.env.GIT_TERMINAL_PROMPT = "0";
+  process.env.GIT_CONFIG_COUNT = String(gitConfig.length);
+  gitConfig.forEach(([key, value], i) => {
+    process.env[`GIT_CONFIG_KEY_${i}`] = key;
+    process.env[`GIT_CONFIG_VALUE_${i}`] = value;
+  });
+}
+
 const tmpDirs: string[] = [];
 
 function makeTmpBase(): string {