aiwcli 0.15.4 → 0.15.7

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,65 @@
+# 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)
+```
+
+## 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
+- `--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 --format json` metadata, (2) tmux pane scrollback capture, (3) static unavailable message
+- Summary persisted to temp file via `persistSummary("devin", ...)`
+
+**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)
+- Session discovery uses `devin list --format json` + `~/.config/cognition/cli/` file scanning
+
+## Library: lib/devin-watcher.ts
+
+Session discovery and summarization:
+- `findDevinSession(projectRoot, launchStartedAtMs)` -- discover session via `devin list` or file scanning
+- `summarizeDevinSession(transcript)` -- AI inference summary
+- `capturePaneScrollback(paneId)` -- tmux pane capture fallback
+
+Re-exports `persistSummary`, `waitForPaneClose` from agent-launcher.
+
+<!-- context-layer: generated=2026-03-06 | version=1 -->

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.

package/dist/templates/core/skills/devin/lib/devin-watcher.ts

@@ -0,0 +1,280 @@
+/**
+ * Devin session discovery and summarization.
+ *
+ * Session discovery strategy (priority order):
+ * 1. `devin list --format json` — parse session metadata, match by cwd + timestamp
+ * 2. File scan of `~/.config/cognition/cli/` for session files
+ * 3. Tmux pane scrollback capture (`tmux capture-pane -p -t <paneId>`)
+ *
+ * If no session transcript is found, falls back to SUMMARY_UNAVAILABLE_MESSAGE.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import path from "node:path";
+
+import { inference } from "../../../lib-ts/runtime/inference.js";
+import { logDebug, logWarn } from "../../../lib-ts/runtime/logger.js";
+import { execFileAsync, findExecutable } from "../../../lib-ts/runtime/subprocess-utils.js";
+
+// Re-export shared symbols for consumers
+export {
+  type PaneWatchTarget,
+  persistSummary,
+  waitForPaneClose,
+} from "../../../lib-ts/runtime/agent-launcher.js";
+
+export const SUMMARY_UNAVAILABLE_MESSAGE = "Devin session completed. Summary unavailable.";
+
+const DEVIN_LIST_TIMEOUT_MS = 10_000;
+const SUMMARY_TIMEOUT_SEC = 10;
+const MAX_SCROLLBACK_LINES = 300;
+const MAX_LINE_LENGTH = 500;
+
+const TRANSCRIPT_SUMMARY_PROMPT = `Summarize this Devin session transcript excerpt.
+Return 3-5 concise bullet points.
+Focus on:
+- what was accomplished
+- files changed
+- errors or blockers
+Do not ask follow-up questions.
+Do not request additional input.
+If information is partial, provide best-effort summary from available text.`;
+
+// ---------------------------------------------------------------------------
+// Session Discovery via `devin list`
+// ---------------------------------------------------------------------------
+
+interface DevinSession {
+  id?: string;
+  session_id?: string;
+  cwd?: string;
+  created_at?: string;
+  status?: string;
+  title?: string;
+  model?: string;
+}
+
+async function getDevinSessions(): Promise<DevinSession[]> {
+  try {
+    const result = await execFileAsync("devin", ["list", "--format", "json"], {
+      timeout: DEVIN_LIST_TIMEOUT_MS,
+    });
+
+    if (result.exitCode !== 0) {
+      logDebug("devin-watcher", `devin list failed: exit=${result.exitCode}`);
+      return [];
+    }
+
+    const parsed = JSON.parse(result.stdout.trim());
+    if (!Array.isArray(parsed)) return [];
+    return parsed as DevinSession[];
+  } catch (error) {
+    logDebug("devin-watcher", `devin list parse failed: ${String(error)}`);
+    return [];
+  }
+}
+
+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;
+}
+
+async function findDevinSessionViaList(
+  projectRoot: string,
+  launchStartedAtMs: number,
+): Promise<DevinSession | null> {
+  const sessions = await getDevinSessions();
+  if (sessions.length === 0) return null;
+
+  // Find sessions matching cwd and started after launch
+  const candidates = sessions.filter((s) => {
+    if (s.cwd && !samePath(s.cwd, projectRoot)) return false;
+    if (s.created_at) {
+      const createdMs = Date.parse(s.created_at);
+      if (createdMs > 0 && createdMs < launchStartedAtMs - 5000) return false;
+    }
+    return true;
+  });
+
+  // Return the most recent matching session
+  if (candidates.length === 0) return null;
+
+  candidates.sort((a, b) => {
+    const aMs = a.created_at ? Date.parse(a.created_at) : 0;
+    const bMs = b.created_at ? Date.parse(b.created_at) : 0;
+    return bMs - aMs;
+  });
+
+  return candidates[0] ?? null;
+}
+
+// ---------------------------------------------------------------------------
+// Session Discovery via File System
+// ---------------------------------------------------------------------------
+
+function findDevinSessionFiles(launchStartedAtMs: number): string[] {
+  const cliDir = path.join(os.homedir(), ".config", "cognition", "cli");
+  if (!fs.existsSync(cliDir)) return [];
+
+  const files: string[] = [];
+  try {
+    const entries = fs.readdirSync(cliDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const fullPath = path.join(cliDir, entry.name);
+      try {
+        const stat = fs.statSync(fullPath);
+        // Only consider files modified after launch
+        if (stat.mtimeMs >= launchStartedAtMs - 5000) {
+          files.push(fullPath);
+        }
+      } catch { /* skip */ }
+    }
+  } catch {
+    logDebug("devin-watcher", "Failed to read ~/.config/cognition/cli/");
+  }
+
+  return files;
+}
+
+function readSessionFileContent(filePath: string): string {
+  try {
+    return fs.readFileSync(filePath, "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tmux Pane Scrollback Capture
+// ---------------------------------------------------------------------------
+
+async function capturePaneScrollback(paneId: string | null | undefined): Promise<string | null> {
+  if (!paneId) return null;
+
+  const tmuxPath = findExecutable("tmux");
+  if (!tmuxPath) return null;
+
+  try {
+    const result = await execFileAsync(tmuxPath, [
+      "capture-pane", "-p", "-t", paneId, "-S", `-${MAX_SCROLLBACK_LINES}`,
+    ], { timeout: 5000 });
+
+    if (result.exitCode !== 0 || !result.stdout.trim()) return null;
+
+    const lines = result.stdout.split(/\r?\n/)
+      .map((line) => {
+        const trimmed = line.trim();
+        return trimmed.length > MAX_LINE_LENGTH
+          ? `${trimmed.slice(0, MAX_LINE_LENGTH)}...`
+          : trimmed;
+      })
+      .filter(Boolean);
+
+    return lines.length > 0 ? lines.join("\n") : null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Summarization
+// ---------------------------------------------------------------------------
+
+function looksLikeBadSummary(output: string): boolean {
+  const normalized = output.toLowerCase();
+  return (
+    normalized.includes("don't see") ||
+    normalized.includes("no output") ||
+    normalized.includes("could you provide") ||
+    normalized.includes("paste")
+  );
+}
+
+function buildTranscriptFromSession(session: DevinSession): string | null {
+  const parts: string[] = [];
+  if (session.title) parts.push(`Title: ${session.title}`);
+  if (session.status) parts.push(`Status: ${session.status}`);
+  if (session.model) parts.push(`Model: ${session.model}`);
+  if (session.id || session.session_id) parts.push(`Session: ${session.id ?? session.session_id}`);
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+
+async function summarizeTranscript(transcript: string): Promise<string | null> {
+  const result = inference(
+    TRANSCRIPT_SUMMARY_PROMPT,
+    `Session transcript excerpt:\n\n${transcript}`,
+    "fast",
+    SUMMARY_TIMEOUT_SEC,
+  );
+
+  if (result.success && result.output?.trim() && !looksLikeBadSummary(result.output)) {
+    return result.output.trim();
+  }
+
+  logWarn("devin-watcher", `Transcript summary failed: ${result.error ?? "empty or low-signal output"}`);
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Main Entry Point
+// ---------------------------------------------------------------------------
+
+/**
+ * Discover and summarize a Devin session.
+ * Tries multiple sources in priority order:
+ * 1. devin list --format json → session metadata summary
+ * 2. ~/.config/cognition/cli/ session files → parse transcript
+ * 3. tmux pane scrollback → raw text summary
+ */
+export async function summarizeDevinSession(
+  projectRoot: string,
+  launchStartedAtMs: number,
+  paneId?: string | null,
+): Promise<string | null> {
+  // Source 1: devin list metadata
+  const session = await findDevinSessionViaList(projectRoot, launchStartedAtMs);
+  if (session) {
+    logDebug("devin-watcher", `Found session via devin list: ${session.id ?? session.session_id ?? "unknown"}`);
+    const sessionMeta = buildTranscriptFromSession(session);
+    if (sessionMeta) {
+      const summary = await summarizeTranscript(sessionMeta);
+      if (summary) return summary;
+    }
+  }
+
+  // Source 2: session files in ~/.config/cognition/cli/
+  const sessionFiles = findDevinSessionFiles(launchStartedAtMs);
+  if (sessionFiles.length > 0) {
+    logDebug("devin-watcher", `Found ${sessionFiles.length} session file(s) in cognition cli dir`);
+    for (const filePath of sessionFiles) {
+      const content = readSessionFileContent(filePath);
+      if (content.length > 50) {
+        const summary = await summarizeTranscript(content);
+        if (summary) return summary;
+      }
+    }
+  }
+
+  // Source 3: tmux pane scrollback
+  const scrollback = await capturePaneScrollback(paneId);
+  if (scrollback) {
+    logDebug("devin-watcher", `Using tmux scrollback (${scrollback.length} chars)`);
+    const summary = await summarizeTranscript(scrollback);
+    if (summary) return summary;
+
+    // Raw fallback: return scrollback lines directly
+    const lines = scrollback.split("\n").slice(-12);
+    if (lines.length > 0) {
+      return `Devin session completed. Transcript fallback:\n- ${lines.join("\n- ")}`;
+    }
+  }
+
+  logWarn("devin-watcher", "No session data found from any source");
+  return null;
+}