aiwcli 0.15.5 → 0.17.0

package/dist/templates/{_shared → core}/skills/codex/scripts/launch-codex.ts

@@ -9,19 +9,26 @@
  */
 import * as fs from "node:fs";
 import * as os from "node:os";
-import * as path from "node:path";
-
-import { launchDriverInTmuxOrFallback } from "../../../lib-ts/base/tmux-driver.js";
-import { cleanupSentinelPath } from "../../../lib-ts/base/sentinel-ipc.js";
-import { getProjectRoot } from "../../../lib-ts/base/constants.js";
-import { resolveCodexModel, codexReplSpec, buildCliInvocation, isCodexSandbox, type CodexSandbox, type CliArgSpec } from "../../../lib-ts/base/cli-args.js";
-import { CODEX_MODELS } from "../../../lib-ts/base/models.js";
-import { logDebug, logWarn } from "../../../lib-ts/base/logger.js";
-import { displayPath } from "../../../lib-ts/base/utils.js";
-import { getContextBySessionId, getContext } from "../../../lib-ts/context/context-store.js";
-import { buildExternalAgentContext } from "../../../lib-ts/context/context-formatter.js";
+import path from "node:path";
+
 import { findLatestPlan } from "../../../lib-ts/context/plan-manager.js";
-import type { ContextState } from "../../../lib-ts/types.js";
+import {
+  cleanupSentinel,
+  eprint,
+  findLatestPlanByMtime,
+  getWellKnownSummaryPath,
+  resolveContextForLaunch,
+  samePath,
+  sleep,
+  writeFileRefPromptFile,
+  writeInlinePromptFile,
+} from "../../../lib-ts/runtime/agent-launcher.js";
+import { aiwLaunch } from "../../../lib-ts/runtime/aiw-cli.js";
+import { resolveCodexModel, buildCliInvocation, isCodexSandbox, type CodexSandbox, type CliArgSpec } from "../../../lib-ts/runtime/cli-args.js";
+import { getProjectRoot } from "../../../lib-ts/runtime/constants.js";
+import { logDebug, logWarn } from "../../../lib-ts/runtime/logger.js";
+import { CODEX_MODELS } from "../../../lib-ts/runtime/models.js";
+import { displayPath } from "../../../lib-ts/runtime/utils.js";
 
 /** Codex-specific model abbreviations. Checked before tier resolution. */
 const CODEX_ALIASES: Record<string, string> = {
@@ -30,22 +37,14 @@ const CODEX_ALIASES: Record<string, string> = {
   gpt: CODEX_MODELS.gpt,
 };
 
-const SESSION_DISCOVERY_TIMEOUT_MS = 12000;
+const SESSION_DISCOVERY_TIMEOUT_MS = 12_000;
 const SESSION_DISCOVERY_POLL_MS = 250;
-const SESSION_MTIME_WINDOW_MS = 120000;
+const SESSION_MTIME_WINDOW_MS = 120_000;
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function eprint(...args: unknown[]): void {
-  process.stderr.write(args.map(String).join(" ") + "\n");
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 function collectSessionJsonlFiles(rootDir: string): string[] {
   if (!fs.existsSync(rootDir)) return [];
   const stack: string[] = [rootDir];
@@ -74,26 +73,21 @@ function collectSessionJsonlFiles(rootDir: string): string[] {
   return files;
 }
 
-function samePath(a: string, b: string): boolean {
-  const left = path.resolve(a);
-  const right = path.resolve(b);
-  if (process.platform === "win32") {
-    return left.toLowerCase() === right.toLowerCase();
-  }
-  return left === right;
-}
-
-function readSessionMeta(sessionFile: string): { sessionId: string; cwd: string } | null {
+function readSessionMeta(sessionFile: string): { sessionId: string; cwd: string; startedAtMs: number } | null {
   try {
-    const raw = fs.readFileSync(sessionFile, "utf-8");
+    const raw = fs.readFileSync(sessionFile, "utf8");
     const firstLine = raw.split(/\r?\n/).find((line) => line.trim().length > 0);
     if (!firstLine) return null;
     const parsed = JSON.parse(firstLine);
     if (parsed?.type !== "session_meta") return null;
     const sessionId = parsed?.payload?.id;
     const cwd = parsed?.payload?.cwd;
+    const startedAt = parsed?.payload?.timestamp;
     if (typeof sessionId !== "string" || typeof cwd !== "string") return null;
-    return { sessionId, cwd };
+    const startedAtMs = typeof startedAt === "string"
+      ? (Date.parse(startedAt) || 0)
+      : 0;
+    return { sessionId, cwd, startedAtMs };
   } catch {
     return null;
   }
@@ -102,12 +96,14 @@ function readSessionMeta(sessionFile: string): { sessionId: string; cwd: string
 function findLatestSessionCandidate(
   projectRoot: string,
   launchStartedAtMs: number,
+  requireProjectCwd = true,
 ): { sessionId: string; sessionFile: string } | null {
   const sessionsRoot = path.join(os.homedir(), ".codex", "sessions");
   const files = collectSessionJsonlFiles(sessionsRoot);
   if (files.length === 0) return null;
 
   const candidates: Array<{ sessionId: string; sessionFile: string; mtimeMs: number }> = [];
+  const currentThreadId = process.env.CODEX_THREAD_ID ?? "";
   for (const sessionFile of files) {
     let mtimeMs = 0;
     try {
@@ -119,7 +115,9 @@ function findLatestSessionCandidate(
 
     const meta = readSessionMeta(sessionFile);
     if (!meta) continue;
-    if (!samePath(meta.cwd, projectRoot)) continue;
+    if (currentThreadId && meta.sessionId === currentThreadId) continue;
+    if (meta.startedAtMs > 0 && meta.startedAtMs < launchStartedAtMs - 1000) continue;
+    if (requireProjectCwd && !samePath(meta.cwd, projectRoot)) continue;
 
     candidates.push({ sessionId: meta.sessionId, sessionFile, mtimeMs });
   }
@@ -136,38 +134,12 @@ async function waitForCaptureSession(
 ): Promise<{ sessionId: string; sessionFile: string } | null> {
   const deadline = Date.now() + SESSION_DISCOVERY_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    const candidate = findLatestSessionCandidate(projectRoot, launchStartedAtMs);
+    const candidate = findLatestSessionCandidate(projectRoot, launchStartedAtMs, true);
     if (candidate) return candidate;
     await sleep(SESSION_DISCOVERY_POLL_MS);
   }
-  return findLatestSessionCandidate(projectRoot, launchStartedAtMs);
-}
-
-/** Fallback plan discovery: scan all context plan dirs by mtime. */
-function findLatestPlanByMtime(projectRoot: string): string | null {
-  const contextsDir = path.join(projectRoot, "_output", "contexts");
-  if (!fs.existsSync(contextsDir)) return null;
-
-  let best: { path: string; mtime: number } | null = null;
-
-  for (const ctxEntry of fs.readdirSync(contextsDir)) {
-    if (ctxEntry.startsWith("_")) continue;
-    const plansDir = path.join(contextsDir, ctxEntry, "plans");
-    if (!fs.existsSync(plansDir)) continue;
-
-    for (const file of fs.readdirSync(plansDir)) {
-      if (!file.endsWith(".md")) continue;
-      const fullPath = path.join(plansDir, file);
-      try {
-        const mtime = fs.statSync(fullPath).mtimeMs;
-        if (!best || mtime > best.mtime) {
-          best = { path: fullPath, mtime };
-        }
-      } catch { /* skip unreadable */ }
-    }
-  }
-
-  return best?.path ?? null;
+  // Fallback: tolerate launcher cwd drift (common on Windows pane backends).
+  return findLatestSessionCandidate(projectRoot, launchStartedAtMs, false);
 }
 
 // ---------------------------------------------------------------------------
@@ -186,6 +158,7 @@ let modelFlag: string | undefined;
 let sandboxFlag: CodexSandbox | undefined;
 let contextFlag: string | undefined;
 let extraPrompt: string | undefined;
+let taskId: string | undefined;
 let yolo = true;
 let watch = true;
 const args: string[] = [];
@@ -204,18 +177,34 @@ for (let i = 0; i < rawArgs.length; i++) {
     contextFlag = rawArgs[++i];
   } else if (rawArgs[i] === "--prompt" && i + 1 < rawArgs.length) {
     extraPrompt = rawArgs[++i];
-  } else if (rawArgs[i] === "--prompt") {
+  } else if (rawArgs[i] === "--task-id" && i + 1 < rawArgs.length) {
+    taskId = rawArgs[++i];
+  } else switch (rawArgs[i]) {
+ case "--no-watch": {
+    watch = false;
+  
+ break;
+ }
+ case "--no-yolo": {
+    yolo = false;
+  
+ break;
+ }
+ case "--prompt": {
     eprint("Error: --prompt requires a text argument.");
     process.exit(1);
-  } else if (rawArgs[i] === "--yolo") {
+  
+ break;
+ }
+ case "--yolo": {
     yolo = true;
-  } else if (rawArgs[i] === "--no-yolo") {
-    yolo = false;
-  } else if (rawArgs[i] === "--no-watch") {
-    watch = false;
-  } else {
+  
+ break;
+ }
+ default: {
     args.push(rawArgs[i]);
   }
+ }
 }
 
 if (args.length === 0) {
@@ -233,21 +222,9 @@ if (modelFlag) {
 }
 
 let promptPath: string | null = null;
-let tempFile: string | null = null;
 
 const projectRoot = getProjectRoot(process.cwd());
-
-// Context lookup — available for all modes (orientation header + plan discovery)
-// --context flag preferred (passed by skill caller); CLAUDE_SESSION_ID as fallback (hooks only)
-let ctx: ContextState | null = null;
-if (contextFlag) {
-  ctx = getContext(contextFlag, projectRoot) ?? null;
-} else {
-  const sessionId = process.env.CLAUDE_SESSION_ID;
-  if (sessionId) {
-    ctx = getContextBySessionId(sessionId, projectRoot) ?? null;
-  }
-}
+const ctx = resolveContextForLaunch(contextFlag, projectRoot);
 
 if (args[0] === "plan") {
   // Plan discovery: context system first, mtime fallback second
@@ -266,8 +243,15 @@ if (args[0] === "plan") {
     process.exit(1);
   }
 
-  promptPath = planPath;
   console.log(`Found plan: ${displayPath(planPath)}`);
+  promptPath = writeFileRefPromptFile({
+    fileReferencePath: path.resolve(planPath),
+    label: "plan",
+    extraPrompt,
+    ctx,
+    projectRoot,
+    tempFilePrefix: "codex",
+  });
 
 } else if (args[0] === "--file") {
   if (!args[1]) {
@@ -279,69 +263,60 @@ if (args[0] === "plan") {
     eprint(`Error: File not found: ${filePath}`);
     process.exit(1);
   }
-  promptPath = filePath;
+  promptPath = writeFileRefPromptFile({
+    fileReferencePath: filePath,
+    label: "file",
+    extraPrompt,
+    ctx,
+    projectRoot,
+    tempFilePrefix: "codex",
+  });
 
 } else {
-  // Inline text: join args, write to temp file
-  const text = args.join(" ");
-  tempFile = path.join(os.tmpdir(), `codex-prompt-${Date.now()}.md`);
-  fs.writeFileSync(tempFile, text, "utf-8");
-  promptPath = tempFile;
-}
-
-// Prepend context orientation if available — graceful degradation on failure
-if (ctx && promptPath) {
-  try {
-    const orientation = buildExternalAgentContext(ctx, projectRoot);
-    const original = fs.readFileSync(promptPath, "utf-8");
-    const combined = `${orientation}\n\n---\n\n${original}`;
-    const contextPromptPath = path.join(os.tmpdir(), `codex-ctx-prompt-${Date.now()}.md`);
-    fs.writeFileSync(contextPromptPath, combined, "utf-8");
-    if (tempFile) {
-      try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
-    }
-    promptPath = contextPromptPath;
-    tempFile = contextPromptPath;
-  } catch {
-    logWarn("codex-skill", `Context orientation prepend failed for ${ctx.id}, continuing without header`);
-  }
-}
-
-if (extraPrompt && promptPath) {
-  try {
-    const base = fs.readFileSync(promptPath, "utf-8");
-    const combined = `${base}\n\n---\n\n## Additional Instructions\n\n${extraPrompt}`;
-    const extraPromptPath = path.join(os.tmpdir(), `codex-extra-prompt-${Date.now()}.md`);
-    fs.writeFileSync(extraPromptPath, combined, "utf-8");
-    if (tempFile) {
-      try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
-    }
-    promptPath = extraPromptPath;
-    tempFile = extraPromptPath;
-  } catch {
-    logWarn("codex-skill", "Extra prompt append failed, continuing without it");
-  }
+  // Inline text: join args, write to temp file with context + extra prompt
+  promptPath = writeInlinePromptFile({
+    text: args.join(" "),
+    extraPrompt,
+    ctx,
+    projectRoot,
+    tempFilePrefix: "codex",
+  });
 }
 
 // ---------------------------------------------------------------------------
 // Launch Codex
 // ---------------------------------------------------------------------------
 
-const codexArgs = buildCliInvocation(codexReplSpec(resolvedModel, sandboxFlag, yolo)).args;
+const launchCwd = process.env.AIW_CALLER_CWD?.trim() || process.cwd();
+
+// Generate task ID if not provided by caller.  Caller-provided IDs enable
+// direct file lookup; auto-generated IDs still allow glob discovery.
+if (!taskId) {
+  taskId = `${Date.now()}-${process.pid}`;
+}
+const wellKnownPath = getWellKnownSummaryPath("codex", taskId, projectRoot);
+// Print task ID and well-known path early — even if the background task
+// output is lost, the caller can note these from partial stdout capture.
+console.log(`Task ID: ${taskId}`);
+console.log(`Summary will be at: ${wellKnownPath}`);
+
 if (yolo) console.log("Mode: YOLO (bypass approvals and sandbox)");
 if (sandboxFlag) console.log(`Sandbox: ${sandboxFlag}`);
 if (resolvedModel) console.log(`Model: ${resolvedModel}${modelFlag !== resolvedModel ? ` (from "${modelFlag}")` : ""}`);
 
-logDebug("codex-skill", `Launching: model=${resolvedModel ?? "default"}, sandbox=${sandboxFlag ?? "default"}, yolo=${yolo}, extraPrompt=${!!extraPrompt}, source=${args[0]}, bytes=${promptPath ? fs.statSync(promptPath).size : 0}`);
+logDebug("codex-skill", `Launching: model=${resolvedModel ?? "default"}, sandbox=${sandboxFlag ?? "default"}, yolo=${yolo}, taskId=${taskId}, extraPrompt=${Boolean(extraPrompt)}, source=${args[0]}, bytes=${promptPath ? fs.statSync(promptPath).size : 0}`);
 
 const launchStartedAtMs = Date.now();
-const result = await launchDriverInTmuxOrFallback({
-  toolName: "codex",
-  mode: "repl",
-  args: codexArgs,
-  splitFlag: "auto",
+
+// Shell out to `aiw launch` instead of importing tmux modules directly.
+// This consolidates all pane-launching logic in the CLI binary.
+const result = await aiwLaunch({
+  codex: true,
+  wait: false,
+  json: true,
+  split: "auto",
   promptPath: promptPath ?? undefined,
-  allowExecFallback: false,
+  cwd: launchCwd,
 });
 
 if (!result.launched) {
@@ -355,13 +330,13 @@ if (!result.launched) {
     sandbox: sandboxFlag ?? "danger-full-access",
   };
   const execInv = buildCliInvocation(execSpec);
-  const promptContent = promptPath ? fs.readFileSync(promptPath, "utf-8") : "";
+  const promptContent = promptPath ? fs.readFileSync(promptPath, "utf8") : "";
 
-  if (tempFile) {
-    try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
+  if (promptPath) {
+    try { fs.unlinkSync(promptPath); } catch { /* ignore */ }
   }
 
-  const { execFileAsync } = await import("../../../lib-ts/base/subprocess-utils.js");
+  const { execFileAsync } = await import("../../../lib-ts/runtime/subprocess-utils.js");
   const execResult = await execFileAsync(execInv.cliName, execInv.args, {
     input: promptContent,
     env: { ...process.env, ...execInv.env },
@@ -379,11 +354,7 @@ if (!result.launched) {
   process.exit(0);
 }
 
-if (tempFile) {
-  try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
-}
-
-const backendLabel = result.backend === "tmux" ? "tmux pane" : (result.backend === "wt" ? "Windows Terminal pane" : "window");
+const backendLabel = result.backend === "tmux" ? "tmux pane" : result.backend === "psmux" ? "psmux pane" : "window";
 if (result.paneId) {
   console.log(`Codex launched in ${backendLabel}: ${result.paneId}`);
 } else {
@@ -393,10 +364,11 @@ if (result.paneId) {
 if (watch && (result.paneId || result.sentinelPath)) {
   try {
     const {
+      persistSummary,
       SUMMARY_UNAVAILABLE_MESSAGE,
       summarizeFromSessionFileFallback,
       summarizeViaResume,
-      summarizeViaSessionFileSpark,
+      summarizeViaSessionFile,
       waitForPaneClose,
     } = await import("../lib/codex-watcher.js");
 
@@ -409,24 +381,38 @@ if (watch && (result.paneId || result.sentinelPath)) {
 
     const sessionFile = sessionInfo?.sessionFile ?? "";
     const sessionId = sessionInfo?.sessionId ?? "";
-    const summary = summarizeViaSessionFileSpark(sessionFile)
+    const summary = (await summarizeViaSessionFile(sessionFile))
       ?? (sessionId ? await summarizeViaResume(sessionId) : null)
       ?? summarizeFromSessionFileFallback(sessionFile)
       ?? SUMMARY_UNAVAILABLE_MESSAGE;
+    const summaryPath = persistSummary(summary, "codex", sessionId || undefined, taskId, projectRoot);
 
     console.log("\n--- Codex Session Summary ---");
     console.log(summary);
+    console.log(`\n[well_known_summary:${wellKnownPath}]`);
+    if (summaryPath) {
+      console.log(`[summary_file:${summaryPath}]`);
+    }
   } catch (error) {
-    logWarn("codex-skill", `Watch flow failed for ${result.paneId ?? result.backend}: ${String(error)}`);
+    logWarn("codex-skill", `Watch flow failed: ${String(error)}`);
+    const fallbackMsg = "Codex session completed. Summary unavailable (watch error).";
+    const { persistSummary: persistFallback } = await import("../lib/codex-watcher.js");
+    const fallbackPath = persistFallback(fallbackMsg, "codex", undefined, taskId, projectRoot);
     console.log("\n--- Codex Session Summary ---");
-    console.log("Codex session completed. Summary unavailable.");
+    console.log(fallbackMsg);
+    console.log(`\n[well_known_summary:${wellKnownPath}]`);
+    if (fallbackPath) {
+      console.log(`[summary_file:${fallbackPath}]`);
+    }
   } finally {
-    cleanupSentinelPath(result.sentinelPath);
+    cleanupSentinel(result.sentinelPath);
   }
 } else {
-  cleanupSentinelPath(result.sentinelPath);
+  cleanupSentinel(result.sentinelPath);
 }
 
 if (result.reason) {
   eprint(`Warning: ${result.reason}`);
 }
+
+

package/dist/templates/{_shared → core}/skills/codex/scripts/watch-codex.ts

@@ -11,7 +11,7 @@ import {
   SUMMARY_UNAVAILABLE_MESSAGE,
   summarizeFromSessionFileFallback,
   summarizeViaResume,
-  summarizeViaSessionFileSpark,
+  summarizeViaSessionFile,
   waitForPaneClose,
 } from "../lib/codex-watcher.js";
 
@@ -27,7 +27,7 @@ async function main(): Promise<void> {
   const sf = sessionFile ?? "";
   const sid = sessionId ?? "";
   const summary =
-    summarizeViaSessionFileSpark(sf) ??
+    (await summarizeViaSessionFile(sf)) ??
     (sid ? await summarizeViaResume(sid) : null) ??
     summarizeFromSessionFileFallback(sf) ??
     SUMMARY_UNAVAILABLE_MESSAGE;
@@ -36,7 +36,9 @@ async function main(): Promise<void> {
   console.log(summary);
 }
 
-main().catch((error) => {
+try {
+  await main();
+} catch (error) {
   console.error(`watch-codex error: ${String(error)}`);
   console.log(SUMMARY_UNAVAILABLE_MESSAGE);
-});
+}

package/dist/templates/core/skills/devin/CLAUDE.md

@@ -0,0 +1,122 @@
+# Devin Skill
+
+Launch Devin CLI in a visible pane (tmux on Unix, fallback to exec mode) and pass the prompt at process start.
+
+## Directory Structure
+
+```
+devin/
+├── CLAUDE.md       <- This file
+├── SKILL.md        <- Skill metadata (user-invocable)
+├── lib/
+│   └── devin-watcher.ts  <- Watch/summarize library
+└── scripts/
+    └── launch-devin.ts   <- Single entry point (launch + optional watch)
+```
+
+## Devin CLI Contract (verified 2026-03-08)
+
+**Always re-verify against the real CLI before changing assumptions.**
+Run `devin list --format json`, `devin --help`, and inspect `~/.local/share/devin/cli/sessions.db` to confirm.
+
+### `devin list --format json` output schema
+
+```jsonc
+{
+  "id": "uuid",                  // full session UUID
+  "short_id": "8-char-hex",
+  "title": "string",            // user prompt or session title
+  "working_directory": "/abs/path",   // NOT "cwd"
+  "working_directory_display": "~/relative",
+  "last_activity_at": 1772942203,     // unix timestamp SECONDS — NOT ISO string, NOT "created_at"
+  "last_activity_ago": "10h ago"
+}
+```
+
+Fields that do **NOT** exist: `cwd`, `created_at`, `status`, `model`, `session_id`.
+
+### Session data storage
+
+- **SQLite DB:** `~/.local/share/devin/cli/sessions.db`
+  - `sessions` table: `id`, `working_directory`, `model`, `created_at` (integer), `last_activity_at`, `title`, `main_chain_id`, `cogs_json`
+  - `message_nodes` table: `session_id`, `node_id`, `chat_message` (JSON with `{role, content}`)
+  - Full conversation transcript (user, assistant, system, tool messages) stored in `message_nodes`
+- **Summary files:** `~/.local/share/devin/cli/summaries/history_<hex>.md` — full session transcripts, NOT Devin-specific (shared with Claude Code sessions). No reliable session-to-file mapping exists.
+- **NOT stored at:** `~/.config/devin/cli/` (only has `config.json`, no session data)
+
+### Devin CLI flags
+
+- `--prompt-file <FILE>` — load prompt from file (NOT positional arg)
+- `--model <MODEL>` — short names: `opus`, `sonnet`, `swe`, `gpt` (server-resolved)
+- `--permission-mode <MODE>` — `auto` (default) or `dangerous`
+- `-p, --print` — non-interactive mode
+- `-r, --resume [SESSION_ID]` — resume session
+- No `--sandbox` or `--yolo` flags (unlike Codex)
+
+## Script: launch-devin.ts
+
+**Usage:**
+```bash
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/devin/scripts/launch-devin.ts [--model <tier|id>] [--prompt <text>] [--no-watch] [--context <id>] plan
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/devin/scripts/launch-devin.ts [--model <tier|id>] [--prompt <text>] [--no-watch] [--context <id>] --file <path>
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/devin/scripts/launch-devin.ts [--model <tier|id>] [--prompt <text>] [--no-watch] [--context <id>] <inline text...>
+```
+
+**Args:**
+- `plan` -- discover active plan via context system, build a bootstrap startup prompt
+- `--file <path>` -- build a bootstrap startup prompt that includes the file path
+- `<text...>` -- join remaining args as inline prompt
+- `--model <name>` -- Models: `swe`, `gpt`, `opus`, `sonnet`. Tiers: `fast`/`standard`/`smart`. Or pass-through.
+- `--prompt <text>` -- append extra instructions
+- `--task-id <id>` -- Caller-provided task ID for direct summary file lookup. If omitted, auto-generated as `<timestamp>-<pid>`. Enables the caller to know the exact summary file path without reading background task stdout.
+- `--no-watch` -- Disable watch/summarize mode
+
+**Plan discovery order:**
+1. `--context` flag or `CLAUDE_SESSION_ID` env -> context -> `findLatestPlan(contextId)`
+2. Fallback: scan `_output/contexts/*/plans/*.md` by mtime
+
+**Dependencies:**
+- `runtime/aiw-cli.ts` -- shells out to `aiw launch --devin`
+- `runtime/agent-launcher.ts` -- shared plan discovery, prompt construction, pane watching
+- `runtime/cli-args.ts` -- Devin model resolution and invocation building
+- `context/*` -- context lookup, formatting, plan discovery
+
+**Watch behavior:**
+- Watch is enabled by default
+- Uses `waitForPaneClose` from shared agent-launcher
+- Summary cascade: (1) `devin list` -> session ID -> SQLite `message_nodes` transcript, (2) tmux pane scrollback capture, (3) static unavailable message
+- Summary persisted to temp file via `persistSummary("devin", ...)` (unique per run)
+- Also writes to well-known path: `$TMPDIR/aiw-agent-output/<session-key>/devin-<taskId>.md`
+- Task ID is caller-provided via `--task-id` or auto-generated as `<timestamp>-<pid>`
+- Caller can compute the exact path via `getWellKnownSummaryPath("devin", taskId)` -- no discovery needed
+- Multiple concurrent agents use different task IDs, so they don't clobber each other
+- Session key resolution: tmux (`$TMUX`), psmux (`psmux display-message`), exec fallback (project-root hash)
+- Task ID + summary path printed early (before agent runs) so even partial stdout capture is useful
+
+**Design decisions:**
+- No sandbox/YOLO flags (Devin uses `--permission-mode` instead, defaulting to `auto`)
+- Devin model short names are server-resolved (we store just the short names)
+- Shared helpers from `agent-launcher.ts` (plan discovery, prompt files, pane watching)
+
+## Library: lib/devin-watcher.ts
+
+Session discovery and summarization:
+- `summarizeDevinSession(projectRoot, launchStartedAtMs, paneId?)` -- full discovery + summary pipeline
+- `collectTranscriptFromDb(sessionId)` -- extract user/assistant messages from SQLite `message_nodes` (uses `python3 -c` to avoid native module dependency)
+- `findDevinSessionViaList(projectRoot, launchStartedAtMs)` -- match session via `devin list --format json` using `working_directory` + `last_activity_at`
+- `capturePaneScrollback(paneId)` -- tmux pane capture fallback
+
+Re-exports `persistSummary`, `waitForPaneClose` from agent-launcher.
+
+---
+## Context Maintenance
+
+**After modifying files in this directory:** scan the entries above -- if any claim is now
+false or incomplete, update this file before ending the task. Do not defer.
+
+**Verification rule:** When changing code that depends on external CLI output formats (field names,
+data types, storage paths), **always verify against the real CLI** before committing. Run the
+actual command and inspect the output. Do not assume field names or paths from memory or from
+other similar tools.
+
+<!-- context-layer: generated=2026-03-06 | last-audited=2026-03-08 | version=3 -->

package/dist/templates/core/skills/devin/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: devin
+description: Delegate implementation to Devin sub-agents. USE WHEN devin OR send to devin OR devin implement OR hand off to devin OR launch devin OR run devin.
+user-invocable: true
+---
+
+# /devin
+
+## Role
+
+You are the orchestrator. Each Devin launch spawns an implementation sub-agent. Delegate implementation work to Devin, then review results when summaries arrive.
+
+The script blocks until Devin exits and prints a session summary. Run with Bash `run_in_background: true` so you stay unblocked and receive the summary as a background task notification.
+
+## Command
+
+```
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/devin/scripts/launch-devin.ts [flags] <mode>
+```
+
+**Modes:** `plan` | `--file <path>` | `<inline text...>`
+
+`plan` and `--file` modes pass a filepath-first bootstrap prompt so Devin reads the file from disk instead of relying on a pasted full document.
+
+**Flags:**
+- `--context <id>` -- Project orientation for the sub-agent. Pass when implementing a plan so Devin understands the project structure.
+- `--prompt <text>` -- Add extra instructions. In `plan`/`--file` mode, this is embedded into the bootstrap temp file with the target path.
+- `--model <name>` -- Models: `swe`, `gpt`, `opus`, `sonnet`. Tiers: `fast`, `standard`, `smart`. Or pass-through for server-side resolution.
+- `--no-watch` -- Fire-and-forget: exit immediately after launch, skip waiting for summary.
+
+## Retrieving Results
+
+The script prints a summary to stdout and writes it to a temp file.
+
+**Primary:** Check TaskOutput for the background task -- the summary and file path are inline.
+
+**Fallback (if TaskOutput is empty):** Look for the `[summary_file:<path>]` line in the output. If found, read that file path directly.
+
+## Delegation Patterns
+
+### One-shot
+
+For small or tightly coupled plans. One sub-agent implements the whole plan.
+
+```bash
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/devin/scripts/launch-devin.ts --context <ctx-id> plan
+```
+
+Run with `run_in_background: true`. Wait for the summary. Review the changes.
+
+### Parallel
+
+For plans with independent sections, create small section-brief files and launch one sub-agent per brief with `--file`.
+
+### Ad-hoc
+
+For tasks outside a plan. Pass inline text or a file path.
+
+```bash
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/devin/scripts/launch-devin.ts \
+  "Fix the failing test in auth.ts"
+
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/devin/scripts/launch-devin.ts \
+  --file path/to/task-description.md
+```
+
+## Orchestrator Checklist
+
+- **Delegate implementation.** If the work involves writing code and Devin can handle it, send it to Devin.
+- **Split independent sections** into parallel sub-agents for faster execution.
+- **Pass `--context`** when implementing a plan -- Devin needs project orientation to make good decisions.
+- **Scope parallel agents with separate `--file` briefs** so each sub-agent has an explicit task boundary.
+- **Review results** when summaries arrive. Check for merge conflicts between parallel agents, then verify with `tsc --noEmit`, tests, or manual inspection.