@monster-orange/den 0.4.12 → 0.4.14

package/src/shared/agents/conversations.ts

@@ -0,0 +1,227 @@
+/**
+ * AG-17.1, bring in a conversation: the runtime's own recent conversations
+ * for a folder, read from its history without ever reading a whole
+ * transcript.
+ *
+ * Claude Code keeps one JSON-lines file per conversation,
+ * `<projects>/<slug>/<id>.jsonl`, where <slug> is the cwd with every
+ * character that isn't a letter or digit made "-" (`/w/a.b` → `-w-a-b`).
+ * The slug alone can't tell `/w/north` from `/w/north-2`, so a
+ * conversation is listed only when the `cwd` its own records carry is the
+ * folder or inside it.
+ *
+ * Each file is read at its two ends only (ENDS_BYTES each): the head for
+ * its cwd and its first prompt, the tail for its latest `/rename`
+ * (custom-title). Title: the latest custom-title, else the first prompt a
+ * person typed, else null. lastAt is the file's mtime: a conversation
+ * written in the last OPEN_ELSEWHERE_MS is taken to be open in another
+ * terminal (one writer only).
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { claudeProjectsDir } from "../usage/paths.js";
+import { cleanName } from "./transcript-follow.js";
+
+/** One of a runtime's conversations, as Bring in lists it. */
+export interface RuntimeConversation {
+  /** The runtime's own id for it (Claude Code: the transcript's name). */
+  id: string;
+  /** Its name for people, or null when it has none yet. */
+  title: string | null;
+  /** When it was last written (ISO). */
+  lastAt: string;
+  /** The folder it ran in. */
+  cwd: string;
+}
+
+/** Bytes read at each end of a transcript. */
+export const ENDS_BYTES = 64 * 1024;
+/** Written this recently: still open in another terminal (AG-17.1). */
+export const OPEN_ELSEWHERE_MS = 60_000;
+/** The most conversations listed for one folder (the newest). */
+export const MAX_CONVERSATIONS = 50;
+
+export const OPEN_ELSEWHERE_MESSAGE =
+  "Still open in another terminal. Close it there first";
+
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+
+/** Claude Code's project folder name for `dir`. */
+export function claudeSlug(dir: string): string {
+  return dir.replace(/[^A-Za-z0-9]/g, "-");
+}
+
+/** Whether `p` is `dir` or inside it. */
+function within(p: string, dir: string): boolean {
+  const rel = path.relative(dir, p);
+  return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+
+/**
+ * The complete lines at the two ends of `file`: at most `bytes` from each.
+ * A line cut at either edge is left out; a short file is all head.
+ */
+export function readEnds(
+  file: string,
+  bytes = ENDS_BYTES,
+): { head: string[]; tail: string[] } {
+  const fd = fs.openSync(file, "r");
+  try {
+    const size = fs.fstatSync(fd).size;
+    const read = (at: number, n: number) => {
+      const buf = Buffer.alloc(n);
+      const got = fs.readSync(fd, buf, 0, n, at);
+      return buf.subarray(0, got).toString("utf-8");
+    };
+    const headText = read(0, Math.min(size, bytes));
+    const head = headText.split("\n");
+    // The whole file: every line. Else the last piece was cut.
+    if (size <= bytes) return { head: head.filter(Boolean), tail: [] };
+    head.pop();
+    const start = Math.max(bytes, size - bytes);
+    const tail = read(start, size - start).split("\n");
+    // The first piece was cut (or is the head's).
+    tail.shift();
+    return { head: head.filter(Boolean), tail: tail.filter(Boolean) };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function parse(line: string): Record<string, unknown> | null {
+  try {
+    const v = JSON.parse(line) as unknown;
+    return v && typeof v === "object" ? (v as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The text a person typed in a user record, or null (tool results, meta). */
+function promptText(rec: Record<string, unknown>): string | null {
+  if (rec.type !== "user" || rec.isMeta === true) return null;
+  const msg = rec.message as { content?: unknown } | undefined;
+  let text: unknown = msg?.content;
+  if (Array.isArray(text)) {
+    const first = text.find(
+      (c) => (c as { type?: unknown })?.type === "text",
+    ) as { text?: unknown } | undefined;
+    text = first?.text;
+  }
+  if (typeof text !== "string") return null;
+  // Slash commands and their output come wrapped in tags: not a prompt.
+  if (text.trimStart().startsWith("<")) return null;
+  return cleanName(text);
+}
+
+/** A transcript's cwd and title, from its two ends. */
+export function transcriptSummary(
+  file: string,
+  bytes = ENDS_BYTES,
+): { cwd: string | null; title: string | null } {
+  const { head, tail } = readEnds(file, bytes);
+  let cwd: string | null = null;
+  let prompt: string | null = null;
+  let title: string | null = null;
+  const titleIn = (line: string) => {
+    if (!line.includes("custom-title")) return;
+    const r = parse(line);
+    if (r?.type === "custom-title") title = cleanName(r.customTitle) ?? title;
+  };
+  for (const line of head) {
+    titleIn(line);
+    if (cwd && prompt) continue;
+    if (!line.includes('"cwd"') && !line.includes('"user"')) continue;
+    const r = parse(line);
+    if (!r) continue;
+    if (!cwd && typeof r.cwd === "string" && path.isAbsolute(r.cwd))
+      cwd = r.cwd;
+    prompt ??= promptText(r);
+  }
+  for (const line of tail) titleIn(line);
+  return { cwd, title: title ?? prompt };
+}
+
+/** A folder's absolute forms: as given and its real path. */
+function forms(dir: string): string[] {
+  const out = [path.resolve(dir)];
+  try {
+    const real = fs.realpathSync(dir);
+    if (!out.includes(real)) out.push(real);
+  } catch {
+    /* gone: as given */
+  }
+  return out;
+}
+
+/**
+ * Claude Code's conversations that ran in `folder` or a folder inside it,
+ * newest first, at most MAX_CONVERSATIONS. Never throws: a history it
+ * can't read is no conversations.
+ */
+export function claudeConversations(
+  folder: string,
+  env: NodeJS.ProcessEnv = process.env,
+): RuntimeConversation[] {
+  const root = claudeProjectsDir(env);
+  const dirs = forms(folder);
+  const slugs = dirs.map(claudeSlug);
+  let projects: string[];
+  try {
+    projects = fs.readdirSync(root);
+  } catch {
+    return [];
+  }
+  const files: { id: string; file: string; mtimeMs: number }[] = [];
+  for (const p of projects) {
+    if (!slugs.some((s) => p === s || p.startsWith(`${s}-`))) continue;
+    let names: string[];
+    try {
+      names = fs.readdirSync(path.join(root, p));
+    } catch {
+      continue;
+    }
+    for (const n of names) {
+      if (!n.endsWith(".jsonl")) continue;
+      const id = n.slice(0, -".jsonl".length);
+      if (!ID_RE.test(id)) continue;
+      const file = path.join(root, p, n);
+      try {
+        const st = fs.statSync(file);
+        if (st.isFile() && st.size > 0)
+          files.push({ id, file, mtimeMs: st.mtimeMs });
+      } catch {
+        /* gone */
+      }
+    }
+  }
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const out: RuntimeConversation[] = [];
+  const seen = new Set<string>();
+  for (const f of files) {
+    if (out.length >= MAX_CONVERSATIONS) break;
+    if (seen.has(f.id)) continue;
+    let s: ReturnType<typeof transcriptSummary>;
+    try {
+      s = transcriptSummary(f.file);
+    } catch {
+      continue;
+    }
+    const cwd = s.cwd;
+    if (!cwd || !dirs.some((d) => within(cwd, d))) continue;
+    seen.add(f.id);
+    out.push({
+      id: f.id,
+      title: s.title,
+      lastAt: new Date(f.mtimeMs).toISOString(),
+      cwd,
+    });
+  }
+  return out;
+}
+
+/** Whether a conversation last written at `lastAt` is still open elsewhere. */
+export function openElsewhere(lastAt: string, now = Date.now()): boolean {
+  const t = Date.parse(lastAt);
+  return Number.isFinite(t) && now - t < OPEN_ELSEWHERE_MS;
+}

package/src/shared/agents/default-pack/be-dev.md

@@ -1,5 +1,6 @@
 ---
 name: be-dev
+role: sde
 description: Implements back-end stories, test first, keeping contracts stable.
 context:
   [

package/src/shared/agents/default-pack/devops.md

@@ -1,5 +1,6 @@
 ---
 name: devops
+role: sde
 description: Builds and maintains pipelines, environments and service configuration.
 context: [the story, the workspace's service manifests, CI configuration]
 ---

package/src/shared/agents/default-pack/fe-dev.md

@@ -1,5 +1,6 @@
 ---
 name: fe-dev
+role: sde
 description: Implements front-end stories, test first, to the design system.
 context:
   [

package/src/shared/agents/default-pack/orchestrator.md

@@ -1,5 +1,6 @@
 ---
 name: orchestrator
+role: orchestrator
 description: Takes the next ready story, picks the persona for it and starts that agent.
 standing: true
 context: [ready work items, running agents in the workspace]
@@ -9,7 +10,8 @@ You are the orchestrator. Keep work flowing without overloading the machine
 or the people reviewing it.
 
 - Take the next ready story, in priority order. Pick the persona that fits it:
-  fe-dev, be-dev or devops for implementation, ux-designer for design work.
+  fe-dev, be-dev or devops for implementation, ux-designer for design work,
+  tester to run the suites.
 - Start one agent per story, in its own worktree, and link it to the story.
 - Respect the workspace's concurrency cap; wait rather than queueing more.
 - When a pull request is opened, ask the reviewer for a review. Never approve

package/src/shared/agents/default-pack/planner.md

@@ -1,5 +1,6 @@
 ---
 name: planner
+role: planner
 description: Writes stories and their acceptance criteria for the workspace.
 standing: true
 context: [the workspace's specs and docs, open work items, the design system]

package/src/shared/agents/default-pack/reviewer.md

@@ -1,5 +1,6 @@
 ---
 name: reviewer
+role: reviewer
 description: Reviews a pull request adversarially. Never approves or merges.
 context: [the pull request and its story, the repo's conventions and tests]
 ---

package/src/shared/agents/default-pack/tester.md

@@ -0,0 +1,16 @@
+---
+name: tester
+role: tester
+description: Runs the test suites and reports failures with repro steps.
+context: [the story and its acceptance criteria, the repo's test commands]
+---
+
+You are the tester. Find out what is broken before anyone ships it.
+
+- Run the workspace's unit, integration and end-to-end suites, as the repo
+  documents them.
+- For each failure, write the exact repro: the smallest failing command, what
+  it printed, and what you expected.
+- Separate real failures from flaky ones; run a suspected flake again before
+  reporting it.
+- Don't fix code. Report what you found to the person or agent who asked.

package/src/shared/agents/default-pack/ux-designer.md

@@ -1,5 +1,6 @@
 ---
 name: ux-designer
+role: designer
 description: Designs flows and screens with the design system, on request.
 context: [the story, the design system, existing screens of the product]
 ---

package/src/shared/agents/den-claude.ts

@@ -61,12 +61,27 @@ import {
   type LaunchOutput,
   type Runtime,
   type RuntimeDetect,
+  type RuntimeModel,
+  type RuntimePermissions,
 } from "./runtime.js";
+import { PERMISSION_INTENTS, type PermissionIntent } from "./permissions.js";
 import { builtinEntry } from "./catalog.js";
 import { catalogFind } from "./catalog-runtime.js";
 import { locateRuntime, type RuntimeFind } from "./runtime-search.js";
 import { claudeProjectsDir } from "../usage/paths.js";
-import { transcriptTitle } from "./transcript-follow.js";
+import { cleanName, transcriptTitle } from "./transcript-follow.js";
+import { claudeConversations } from "./conversations.js";
+
+/**
+ * `/rename "x"` keeps the quotes in customTitle: one matching pair around
+ * the whole name goes, for display only (0.4.13). Nothing inside: null.
+ */
+export function unquoteTitle(name: string | null): string | null {
+  if (!name || name.length < 2) return name;
+  const q = name[0];
+  if ((q !== '"' && q !== "'") || name[name.length - 1] !== q) return name;
+  return cleanName(name.slice(1, -1));
+}
 
 export const DEN_CLAUDE_ID = "den-claude";
 const BIN = "claude";
@@ -90,12 +105,91 @@ export const PERMISSION_MODES = [
 ] as const;
 export const DEFAULT_PERMISSION_MODE = "default";
 
-/** The persona's permission mode, checked; a bad one names the key. */
+/**
+ * Den's permission intents (AG-13) as Claude Code's modes:
+ * https://code.claude.com/docs/en/iam (permission modes): `default` asks
+ * on first use of each tool, `acceptEdits` accepts file edits for the
+ * session, `bypassPermissions` skips every prompt.
+ */
+export const INTENT_MODE: Record<PermissionIntent, string> = {
+  ask: "default",
+  edits: "acceptEdits",
+  all: "bypassPermissions",
+};
+
+/**
+ * One plain command prefix as Claude Code allow rules (the same docs,
+ * Bash rules): the command alone, and the command with arguments (`*`
+ * matches any run of characters). Deny rules (Den's state dir) still win:
+ * Claude Code checks deny before allow.
+ */
+export const COMMAND_RULES = ["Bash({c})", "Bash({c} *)"];
+
+/** How den-claude expresses permission intents (AG-13.2). */
+export const DEN_CLAUDE_PERMISSIONS: RuntimePermissions = {
+  modes: {
+    ask: "--permission-mode default: asks before edits and commands",
+    edits:
+      "--permission-mode acceptEdits: file edits run without asking; commands ask",
+    all: "--permission-mode bypassPermissions: nothing asks",
+  },
+  commandRules: COMMAND_RULES,
+};
+
+/** A command prefix's allow rules (permissions.ts checked it). */
+export function allowRules(commands: readonly string[]): string[] {
+  return commands.flatMap((c) =>
+    COMMAND_RULES.map((r) => r.split("{c}").join(c)),
+  );
+}
+
+/**
+ * Claude Code's models (AG-12.3): the aliases `claude --model` takes,
+ * each "latest" (the alias tracks its newest model) or pinned to one full
+ * model id. Claude Code has no command that lists models, so the list
+ * ships with each Den release (https://code.claude.com/docs/en/model-config:
+ * aliases opus, sonnet, haiku, or a full model name). Newest first.
+ */
+export const DEN_CLAUDE_MODELS: readonly RuntimeModel[] = [
+  {
+    id: "opus",
+    label: "Opus",
+    versions: [
+      "claude-opus-5-5",
+      "claude-opus-5",
+      "claude-opus-4-8",
+      "claude-opus-4-7",
+      "claude-opus-4-6",
+    ],
+    latest: "claude-opus-5-5",
+  },
+  {
+    id: "sonnet",
+    label: "Sonnet",
+    versions: ["claude-sonnet-5-5", "claude-sonnet-5", "claude-sonnet-4-6"],
+    latest: "claude-sonnet-5-5",
+  },
+  {
+    id: "haiku",
+    label: "Haiku",
+    versions: ["claude-haiku-5-5", "claude-haiku-4-5"],
+    latest: "claude-haiku-5-5",
+  },
+];
+
+/**
+ * The mode to launch with: the agent's intent (Start › Advanced), else the
+ * persona's `permission_mode`: one of Den's intents, or one of Claude
+ * Code's own modes (as before AG-13). A bad one names the key.
+ */
 function permissionMode(input: LaunchInput): string {
+  if (input.permission) return INTENT_MODE[input.permission];
   const m = input.persona.permissionMode ?? DEFAULT_PERMISSION_MODE;
+  if ((PERMISSION_INTENTS as readonly string[]).includes(m))
+    return INTENT_MODE[m as PermissionIntent];
   if (!(PERMISSION_MODES as readonly string[]).includes(m))
     throw new LaunchError(
-      `${input.persona.source}: permission_mode "${m.replace(/[^\x20-\x7e]/g, "?").slice(0, 40)}" must be one of ${PERMISSION_MODES.join(", ")}`,
+      `${input.persona.source}: permission_mode "${m.replace(/[^\x20-\x7e]/g, "?").slice(0, 40)}" must be one of ${[...PERMISSION_INTENTS, ...PERMISSION_MODES].join(", ")}`,
     );
   return m;
 }
@@ -244,7 +338,9 @@ function common(input: LaunchInput): {
         }),
       )
     : null;
-  const settings = input.stateDir || hooks ? settingsPath(input) : null;
+  const allow = allowRules(input.allow ?? []);
+  const settings =
+    input.stateDir || hooks || allow.length ? settingsPath(input) : null;
   return {
     argv: [
       "--mcp-config",
@@ -268,13 +364,18 @@ function common(input: LaunchInput): {
         ? {
             [settings]: `${JSON.stringify(
               {
-                ...(input.stateDir
+                ...(input.stateDir || allow.length
                   ? {
                       permissions: {
-                        deny: stateDirDenyRules(
-                          input.stateDir,
-                          input.env?.HOME,
-                        ),
+                        ...(allow.length ? { allow } : {}),
+                        ...(input.stateDir
+                          ? {
+                              deny: stateDirDenyRules(
+                                input.stateDir,
+                                input.env?.HOME,
+                              ),
+                            }
+                          : {}),
                       },
                     }
                   : {}),
@@ -289,7 +390,9 @@ function common(input: LaunchInput): {
     warnings:
       mode === "bypassPermissions"
         ? [
-            `⚠ persona ${input.persona.id} sets permission_mode: bypassPermissions: Claude Code will not ask before running any tool`,
+            input.permission === "all"
+              ? `⚠ agent ${input.agentId} starts with auto-approve all (bypassPermissions): Claude Code will not ask before running any tool`
+              : `⚠ persona ${input.persona.id} sets permission_mode: bypassPermissions: Claude Code will not ask before running any tool`,
           ]
         : [],
   };
@@ -347,6 +450,9 @@ export const denClaude: Runtime = {
   denTools: true,
   firstPrompt: true,
   find: DEN_CLAUDE_FIND,
+  models: () =>
+    DEN_CLAUDE_MODELS.map((m) => ({ ...m, versions: [...m.versions] })),
+  permissions: DEN_CLAUDE_PERMISSIONS,
   detect,
   launch(input): LaunchOutput {
     const bin = binFor(input);
@@ -383,14 +489,23 @@ export const denClaude: Runtime = {
   conversationExists(token, env = process.env) {
     return transcriptFile(token, env) !== null;
   },
+  // AG-17.1: its transcripts for the folder (conversations.ts).
+  listSessions(cwd, env = process.env) {
+    try {
+      return claudeConversations(cwd, env);
+    } catch {
+      return [];
+    }
+  },
   // AG-4b, unofficial (catalog sessionName): `/rename` appends a
   // {"type":"custom-title","customTitle":…} record to the transcript; the
-  // latest one, read on from the last ask (never the whole file). Null on
-  // any failure: it must never break a pane.
+  // latest one, read on from the last ask (never the whole file), less one
+  // pair of surrounding quotes. Null on any failure: it must never break a
+  // pane.
   sessionName(rec, env = process.env) {
     try {
       const file = transcriptFile(rec.resumeToken, env);
-      return file ? transcriptTitle(file) : null;
+      return file ? unquoteTitle(transcriptTitle(file)) : null;
     } catch {
       return null;
     }

package/src/shared/agents/permissions.ts

@@ -0,0 +1,108 @@
+/**
+ * Permissions as intent (AG-13): what a person chooses, before any
+ * runtime's syntax.
+ *
+ *   ask    Ask for everything (the default)
+ *   edits  Auto-approve edits in the worktree
+ *   all    Auto-approve all (a session started so is always tagged)
+ *
+ * And extra allowed commands: plain command prefixes ("npm test"), one per
+ * entry, no patterns. Each runtime translates both into its own launch
+ * config (den-claude.ts); a runtime that can't express one says so, and it
+ * is never silently dropped. What a persona pack shares is this intent
+ * only, never vendor syntax.
+ */
+
+export const PERMISSION_INTENTS = ["ask", "edits", "all"] as const;
+export type PermissionIntent = (typeof PERMISSION_INTENTS)[number];
+export const DEFAULT_INTENT: PermissionIntent = "ask";
+
+/**
+ * A persona's `permission_mode` as an intent. Den's three intents are
+ * themselves; Claude Code's own modes from before AG-13 read as the intent
+ * they meant (default, acceptEdits, bypassPermissions). Anything else
+ * (Claude Code's plan, a typo) is not an intent: undefined, and the
+ * runtime decides (den-claude refuses a mode it doesn't know).
+ */
+export function intentOf(
+  mode: string | undefined,
+): PermissionIntent | undefined {
+  if (mode === undefined) return DEFAULT_INTENT;
+  if ((PERMISSION_INTENTS as readonly string[]).includes(mode))
+    return mode as PermissionIntent;
+  if (mode === "default") return "ask";
+  if (mode === "acceptEdits") return "edits";
+  if (mode === "bypassPermissions") return "all";
+  return undefined;
+}
+
+/** The most extra commands one persona or launch takes. */
+export const MAX_COMMANDS = 32;
+/** The longest command prefix. */
+export const MAX_COMMAND_LEN = 120;
+/**
+ * What a plain prefix is made of: letters, digits, spaces and . _ / : = @
+ * % + , -. No shell syntax (quotes, ;, &, |, $, backticks, redirects) and
+ * no pattern characters (* ? [ ] ^ ( ) { }): Den translates a prefix, it
+ * never passes one through a shell.
+ */
+const PREFIX_RE = /^[A-Za-z0-9][A-Za-z0-9 ._/:=@%+,-]*$/;
+const PATTERN_RE = /[*?[\]^$(){}|]/;
+
+export type CommandProblem = "pattern" | "invalid" | "long";
+
+/** Why `c` isn't a plain prefix, or null when it is. */
+export function commandProblem(c: string): CommandProblem | null {
+  if ([...c].length > MAX_COMMAND_LEN) return "long";
+  if (PATTERN_RE.test(c)) return "pattern";
+  if (!PREFIX_RE.test(c) || /\s{2,}/.test(c) || c !== c.trim())
+    return "invalid";
+  return null;
+}
+
+const shown = (v: unknown) =>
+  (JSON.stringify(v) ?? "undefined").replace(/[^\x20-\x7e]/g, "?").slice(0, 60);
+
+/**
+ * A list of extra allowed commands, checked: an array of plain prefixes
+ * (each trimmed, duplicates dropped), at most MAX_COMMANDS. undefined or
+ * null is none. Anything else throws, naming the entry and why.
+ */
+export function checkCommands(v: unknown, where: string): string[] {
+  if (v === undefined || v === null) return [];
+  if (!Array.isArray(v))
+    throw new Error(`${where}: must be a list of command prefixes`);
+  if (v.length > MAX_COMMANDS)
+    throw new Error(`${where}: at most ${MAX_COMMANDS} commands`);
+  const out: string[] = [];
+  v.forEach((x, i) => {
+    if (typeof x !== "string")
+      throw new Error(`${where}[${i}]: must be a string`);
+    const c = x.trim();
+    const why = c ? commandProblem(c) : "invalid";
+    if (why === "pattern")
+      throw new Error(
+        `${where}[${i}]: ${shown(c)} is a pattern: use a plain prefix ("npm test")`,
+      );
+    if (why === "long")
+      throw new Error(`${where}[${i}]: at most ${MAX_COMMAND_LEN} characters`);
+    if (why)
+      throw new Error(
+        `${where}[${i}]: ${shown(c)} must be a plain prefix: letters, digits, single spaces and . _ / : = @ % + , -`,
+      );
+    if (!out.includes(c)) out.push(c);
+  });
+  return out;
+}
+
+/** An intent, checked; a usage message naming `where` otherwise. */
+export function checkIntent(v: unknown, where: string): PermissionIntent {
+  if (
+    typeof v === "string" &&
+    (PERMISSION_INTENTS as readonly string[]).includes(v)
+  )
+    return v as PermissionIntent;
+  throw new Error(
+    `${where}: ${shown(v)} must be one of ${PERMISSION_INTENTS.join(", ")}`,
+  );
+}