linersh 0.5.0

package/dist/agents/prompts.js

@@ -0,0 +1,301 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Companion files referenced by each phase per SKILL.md. The agent is told
+ * which ones to read at the top of the relevant phase.
+ */
+const COMPANIONS = {
+    candidates: ["source-finding-tactics.md"],
+    evaluation: ["source-quality-hierarchy.md", "curator-notes.md"],
+    quality: ["quality-check-tests.md"],
+    synthesis: ["synthesis-guidance.md"],
+};
+const PHASE_INSTRUCTIONS = {
+    framing: `## Phase 1 — Framing
+
+Define the job-to-be-done and sketch the knowledge map.
+
+- The JTBD is a *single specific sentence*, not a topic. The user already provided a draft in tape.yaml.jtbd and in working/01-jtbd-and-knowledge-map.md. Read both.
+- **Read \`tape.yaml.jtbd_clarifications\` if present.** Those are the user's answers to sharpening questions about scope splits, expected output kinds, quality anchors, and audience model. Weight the knowledge map by them. For example: if the user said two domains are equally weighted, give them equal section counts; if the user named specific tools as quality anchors, build sections that match the conceptual coverage those tools cover.
+- If the draft JTBD is genuinely a topic (e.g. "Mobile design") and the clarifications didn't sharpen it, push back in your output and ask the user to revise.
+- The knowledge map is 4–8 sections, each with a few sub-areas. Treat it as a hypothesis to be revised during research. If two domains were named in the JTBD or clarifications, sections must visibly cover BOTH — uneven coverage is a framing failure.
+
+**You MUST remove the placeholder line** \`TODO — Phase 1 replaces this with 4–8 sections…\` from working/01-jtbd-and-knowledge-map.md as part of writing the real knowledge map. That sentinel is how the TUI knows Phase 1 has been completed — leaving it in place will keep the hub's progress cursor stuck on Framing even after you write good content.
+
+Write the result to working/01-jtbd-and-knowledge-map.md (overwriting placeholders including the sentinel above, keeping the JTBD line as-is). Stop after this file is written. Do not start Phase 2.`,
+    candidates: `## Phase 2 — Candidate discovery
+
+Read working/01-jtbd-and-knowledge-map.md for the JTBD and knowledge map. Then read the companion file \`source-finding-tactics.md\` in the skill bundle.
+
+- Generate a long-list of candidate sources covering every section of the knowledge map. URLs and titles only — NO fetching yet.
+- Aim wide: 2–4× the eventual kept count.
+- **Verify each URL exists** via WebFetch (or your fetch tool) — AI hallucinates URLs that sound plausible. A 404 candidate is worse than a missing one.
+- For each candidate, capture: URL, title, one-line reason it's a candidate.
+
+**Search YouTube too, not just the web.** Liner fetches video transcripts and titles automatically (\`youtube.com/watch?v=…\` and \`youtu.be/…\` URLs are first-class sources). For most JTBDs there will be conference talks, lectures, or long-form interviews on YouTube that cover the topic from a different angle than written articles do. Look there explicitly. The quality hierarchy (in \`source-quality-hierarchy.md\`) treats conference talks from credible speakers as tier-3 sources — equal in standing to expert articles. Skip TED-style talks unless density is unusually high.
+
+Write to working/02-candidate-longlist.md, grouped by knowledge-map section. Stop after this file is written.
+
+⚠ Bias correction: do NOT default to popular/recent sources. Search deliberately for primary sources (specs, canonical papers, official docs, foundational books). Mix media types — articles, YouTube talks/lectures, papers, primary docs.`,
+    evaluation: `## Phase 4 — Evaluation
+
+Read working/02-candidate-longlist.md. Then read the companion files \`source-quality-hierarchy.md\` and \`curator-notes.md\` in the skill bundle. Then fetch each candidate's content (transcripts for YouTube; readable body for web articles).
+
+For each candidate, decide keep / trim / drop against the JTBD. For kept and trimmed sources, write a rating (1–5) and a curator note in the three-thing template (role / where the value is / limitations).
+
+Write decisions to working/03-evaluation.yaml in the format:
+
+\`\`\`yaml
+candidates:
+  - url: https://...
+    title: ...
+    decision: kept   # kept | trim | dropped
+    rating: 5
+    section: foundations
+    rationale: One specific sentence.
+    note: |
+      Multi-line curator note for kept/trim sources. Use the three-thing template.
+\`\`\`
+
+Stop after this file is written. Do not draft synthesis yet.`,
+    quality: `## Phase 5 — Quality checks
+
+Read working/03-evaluation.yaml. Then read \`quality-check-tests.md\` in the skill bundle — note especially the strengthened framing-gap rules below.
+
+Run the five tests against the keep-list:
+1. Redundancy — any two kept sources making essentially the same point?
+2. Coverage — any knowledge-map section with zero sources?
+3. Disagreement — strongest claim with a credible counter included?
+4. Framing-gap — is any whole way of thinking about the JTBD missing?
+5. Source-kind balance — distribution across the four kinds. Any kind at zero must be defended or backfilled.
+
+**Framing-gap test rules (strict)**:
+
+- Before looking at the keep-list, NAME 2–3 candidate perspectives that could exist outside the corpus (e.g. designer voice, accessibility-first viewpoint, security/abuse perspective, contrarian, adjacent discipline). Write them into working/04-quality-checks.md.
+- For each named perspective, classify coverage in TWO dimensions:
+  - **Stance** — is there a verified source whose author *argues for* this perspective as a design center of gravity? \`stance-represented\` or \`stance-absent\`.
+  - **Concerns** — do any kept sources address the perspective's operational concerns, even from a different stance? \`concerns-addressed\` or \`concerns-absent\`.
+  A perspective is fully covered only when its stance is represented. \`concerns-addressed\` alone is a SOFT GAP — the corpus internalizes the concern without giving the consuming AI a worked rival argument to cite.
+- **Unverified sources do NOT count.** A source whose Phase 4 note acknowledges unfetched content, broken URLs, or unobtainable transcripts cannot satisfy a perspective slot. Tokenism is the failure mode this rule prevents.
+- For each perspective that is not \`stance-represented\`, take exactly one of three actions:
+  - **(a) Search for a stance source.** Vocabulary: who would *argue for* this position, what would they write, where would they publish? (e.g., "Brandur Leach on terminal density," not "CLI scriptability best practices.") One search pass; if a verified source fits, add it.
+  - **(b) Argue concerns are sufficient.** Write the argument explicitly: "Concerns covered by [Sources N, M] inside the [dominant] stance. The dissenting stance is real but its operational implications are absorbed; no separate source needed." Not a free pass — if you can't articulate the trade-off, fall back to (a) or (c).
+  - **(c) Flag the bias explicitly.** Document: "Perspective: [name] — stance unrepresented after one search pass. Corpus argues from [X] but no source argues for [Y]. Recommendation: ship + document, OR weaken the JTBD claim."
+
+**Source-kind balance rules**:
+
+- The four kinds are \`reference / principle / prescription / example\`. They represent four argumentative roles in the corpus.
+- Count the distribution. A zero in any column is a decision, not an accident.
+- 0 \`reference\` → no substrate authority. 0 \`principle\` → no philosophical anchor. 0 \`prescription\` → no concrete rules. 0 \`example\` → no taste calibration.
+- For each zero, either backfill (one search pass for a source of that role) or write a defense: "Kinds audit: X/Y/Z/W. Accepted: [reason this JTBD legitimately doesn't need that kind]."
+
+**Required output structure** in working/04-quality-checks.md:
+
+\`\`\`
+## Test 1 — Redundancy
+[finding + action]
+
+## Test 2 — Coverage
+[finding + action]
+
+## Test 3 — Disagreement
+[finding + action]
+
+## Test 4 — Framing-gap
+
+### Perspectives audit
+- [Perspective name] — stance-represented (Source N, verified) ✓
+- [Perspective name] — stance-absent, concerns-absent. Backfill: searched [vocabulary], found [source] → now stance-represented (Source M) ✓
+- [Perspective name] — stance-absent, concerns-addressed by [Sources L, K]. Argued sufficient: [explicit trade-off paragraph].
+   OR
+- [Perspective name] — stance-absent after one search pass. Corpus argues from [X], no source argues for [Y]. Recommendation: [...].
+
+## Test 5 — Source-kind balance
+
+Distribution: X reference / Y principle / Z prescription / W example
+[If any zero: backfill action OR defense paragraph]
+\`\`\`
+
+Every named perspective must appear in the audit with explicit coverage status. A missing "Perspectives audit" section, or a Test 5 section without the distribution, means the test wasn't run honestly.
+
+If a test fails, fix the keep-list (update working/03-evaluation.yaml) before reporting done. Even tests that pass without changes should be noted — silent passes train the model to treat the tests as ceremonial.
+
+Stop after working/04-quality-checks.md is written and any necessary changes are reflected in 03-evaluation.yaml.`,
+    synthesis: `## Phase 6 — Synthesis
+
+Read synthesis.md (replacing the placeholder), working/03-evaluation.yaml (the keep-list), and \`synthesis-guidance.md\` in the skill bundle.
+
+Draft synthesis.md as continuous prose, 800–2000 words. The synthesis is the curator's *distilled understanding of the domain* — principles, contested questions, framework distinctions. NOT a recap of source content.
+
+⚠ Bias correction: do NOT write "Source 1 says X; Source 2 says Y." Push toward the curator's framing. Synthesis is the first thing the consuming AI reads — it sets the lens.
+
+**Weight sources by their \`kind\`** (set during Phase 7, but visible in 03-evaluation.yaml too):
+- \`reference\` sources (specs, RFCs) — substrate. Cite once for authority; don't lean on them for framing.
+- \`principle\` sources (essays, manifestos) — load-bearing for the synthesis's stance section. These earn the most quoting.
+- \`prescription\` sources (style guides, rules) — useful for concrete distinctions but rarely for the synthesis's voice.
+- \`example\` sources (case studies, surveys) — taste calibration. Cite when arguing what "good" looks like.
+
+If a source's \`kind\` field is absent, treat it as principle-equivalent (the synthesis-writing default).
+
+For methodology mode, mark spots where the curator should personalize ("[curator's view: …]") so they have explicit handoff points. For quick mode, write a coherent draft they can lightly edit.
+
+Stop after synthesis.md is written.`,
+    assembly: `## Phase 7 — Assembly (draft)
+
+You are preparing a *draft* of the sources list for the curator to review. **DO NOT touch tape.yaml directly.** Write your proposal to \`working/07-tape-draft.yaml\` and stop.
+
+Read these inputs:
+- \`working/03-evaluation.yaml\` — the keep-list with curator notes and ratings.
+- \`synthesis.md\` — the curator's framing, to inform section ordering.
+- \`tape.yaml\` — preserve any existing source order the curator already chose; you're proposing additions/changes, not erasing.
+
+Build the draft as YAML with a top-level \`sources:\` list. Each entry needs:
+
+\`\`\`yaml
+sources:
+  - type: web         # web | youtube | local_file
+    url: https://...
+    section: foundations
+    priority: required   # required | optional
+    kind: prescription   # reference | principle | prescription | example
+    note: |
+      One-paragraph curator note: role of this source, where the value lives,
+      and any limitations. Use the three-thing template.
+\`\`\`
+
+Rules:
+- Only include candidates marked \`kept\` or \`trim\` in 03-evaluation.yaml. Drop everything else.
+- Within a section, order by rating (highest first).
+- Order sections in reading order: foundations / patterns / applications / craft (or whatever the synthesis suggests).
+- Notes come straight from 03-evaluation.yaml's \`note\` field. Do not paraphrase.
+- Mark a source \`priority: optional\` only when the methodology genuinely treats it as skippable (rare).
+- \`local_file\` entries: only include them if 03-evaluation.yaml already has them. Never invent paths.
+
+**Source \`kind\` is required on every entry.** It tells the synthesis prompt and the consuming AI which sources to weight how. Pick the best fit:
+
+- \`reference\` — specs / standards cited but not deep-read (POSIX, RFCs, official manual pages). The consuming AI cites these for authority but doesn't quote them at length.
+- \`principle\` — read for stance / framing (essays, manifestos, philosophical pieces). Shapes how the AI thinks about the domain.
+- \`prescription\` — read for concrete rules (style guides, conventions, explicit do/don't lists). The AI quotes these directly when applying rules.
+- \`example\` — read for taste / illustration (case studies, tool surveys, worked examples). Shows what good looks like.
+
+A source can plausibly fit two categories; pick the one closest to *how the consuming AI should USE this source*. When in doubt: rules → \`prescription\`; arguments → \`principle\`; examples → \`example\`; authority without narrative → \`reference\`.
+
+When done, write \`working/07-tape-draft.yaml\` and stop. The TUI will show the curator a review screen to accept, edit, or discard. DO NOT modify tape.yaml.`,
+    empirical: `## Phase 8 — Empirical test
+
+Read MIXTAPE.md (if present) and the project's JTBD. Then check whether \`tape.yaml\` has a \`parent\` field set:
+
+**If \`tape.parent\` is NOT set** (the default), run the standard with-vs-without test:
+
+1. Suggest 2–3 substantive questions that should benefit from the JTBD.
+2. Show what a "with mixtape" answer should be able to do that a "without mixtape" answer cannot.
+3. Help the user record both responses and write a verdict to working/05-empirical-test.md.
+
+**If \`tape.parent\` IS set**, the project is a replay of an earlier mixtape — set by \`liner replay\`. Run a v1-vs-v2 comparison test instead:
+
+1. Read the parent project's MIXTAPE.md and synthesis.md (the path is in tape.parent).
+2. Suggest 2–3 substantive questions that should benefit from the JTBD.
+3. For the agreed question, show what answers using the v1 mixtape vs the v2 mixtape should be able to do differently. The hypothesis is that v2 covers a perspective v1 missed, or has sharper framing — be specific about WHICH dimension to compare on (perspective coverage, framing sharpness, specific claims included or dropped).
+4. Help the user record both "with v1" and "with v2" responses and write a verdict to working/05-empirical-test.md naming a concrete difference and which corpus better serves the JTBD.
+
+This phase is interactive — talk with the user to pick the question and capture the verdict. Stop after working/05-empirical-test.md has a real question + verdict.`,
+};
+/** Construct the system+user prompt blob passed to the agent. */
+export function buildPhasePrompt(args) {
+    const { phaseId, project, skillPath, tape } = args;
+    const skillContents = safeRead(join(skillPath, "SKILL.md")) ??
+        "(SKILL.md not found at " + skillPath + ")";
+    const phaseInstruction = PHASE_INSTRUCTIONS[phaseId] ??
+        `## Phase ${phaseId}\n\nNo dedicated instruction. Use SKILL.md to figure out what to do for the ${phaseId} phase, then stop.`;
+    const companionNote = (COMPANIONS[phaseId] ?? [])
+        .map((f) => `  - ${join(skillPath, f)}`)
+        .join("\n");
+    return `You are running the curating-mixtapes methodology on behalf of a curator.
+
+# Mixtape context
+
+- Project folder: ${project}
+- Title: ${tape.title || "(not set)"}
+- Description: ${tape.description || "(not set)"}
+- Mode: ${tape.mode ?? "quick"}
+- JTBD: ${tape.jtbd || "(not set)"}
+- Curator: ${tape.curator || "(not set)"}
+- Sources currently on tape: ${tape.sources.length}
+
+# Skill bundle
+
+The methodology is documented in:
+  - ${join(skillPath, "SKILL.md")}
+
+Companion files (read the ones listed in the phase instructions below):
+${companionNote || "  (none for this phase)"}
+
+# What to do
+
+${phaseInstruction}
+
+# Output discipline
+
+- Work on the filesystem. Do not paste large file contents back in your response — write them to disk.
+- Be concise in your spoken output. The user is watching a TUI; long monologues clutter the screen.
+- If you cannot proceed (missing JTBD, missing prior-phase artifact), say so clearly and stop. Do NOT make up content.
+
+# Final message format (required)
+
+When the phase finishes, end with a markdown message in **this exact shape**.
+The TUI renders this — section headings (**Bold:**) become colored chips, bullets render with • glyphs, and bracketed paths render dim. Following the format gives the curator a scannable summary; freeform prose does not.
+
+\`\`\`
+Done with Phase N.
+
+**What I did:**
+- Verb-first sentence describing one concrete output [path/to/file]
+- Another verb-first sentence [path/to/another-file]
+
+**Mix:** (only if you discovered or surveyed sources — skip otherwise)
+- Category one: short list of representative items
+- Category two: short list
+
+**Review checklist:** (only if there's something the curator should verify in *this TUI screen* before moving on — skip if not)
+- A specific judgment call to make from what's visible here
+- Another specific judgment call
+\`\`\`
+
+Rules:
+- **Lead every bullet with a verb-phrase**, not a file path or URL. Put paths in \`[brackets]\` at the very end of the bullet.
+- Don't introduce extra sections. The TUI styles only these three headings; anything else renders as plain text.
+- Skip sections that don't apply. Better to omit "Mix:" than to fill it with filler.
+- 2–4 bullets per section. Be specific, not exhaustive.
+- For the opening line ("Done with Phase N.") use the actual phase number — not "this phase" or "the current phase".
+
+**Review checklist — scope rules** (important):
+
+The "Review checklist" is what the curator should do on the **current TUI done screen**, before pressing Enter to advance. The TUI's only affordances at that moment are: read your message, open the artifact file in \`$EDITOR\`, re-run the phase, or continue. So bullets must be answerable by ONE of:
+
+- A yes/no judgment the curator can make by skimming what you wrote ("Does the knowledge map cover X?")
+- A specific edit they can make to the artifact you just wrote ("Drop the InfoQ Q&A in the long-list — weakest entry")
+- A specific source/section worth a closer look ("The Pinsker entry skews designer-voice — confirm or swap")
+
+Do NOT include bullets that ask the curator to:
+- Go find more sources (the next phase handles selection — flag it for *yourself* in a later phase note, not for them)
+- Add categories or sections you didn't include (you should have included them)
+- "Flag if you want a dedicated source for X" — that's outside the loop the TUI gives them
+- Do open-ended research, validation, or thinking that requires leaving this screen
+- Anything that doesn't fit "read → edit artifact in \$EDITOR → advance"
+
+If you don't have a concrete TUI-scoped checklist item, **omit the section**. An empty Review checklist is better than one full of asks the curator can't act on from where they are.
+
+# Full SKILL.md follows
+
+${skillContents}
+`;
+}
+function safeRead(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=prompts.js.map

package/dist/agents/prompts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../../src/agents/prompts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAIjC;;;GAGG;AACH,MAAM,UAAU,GAAuC;IACrD,UAAU,EAAE,CAAC,2BAA2B,CAAC;IACzC,UAAU,EAAE,CAAC,6BAA6B,EAAE,kBAAkB,CAAC;IAC/D,OAAO,EAAE,CAAC,wBAAwB,CAAC;IACnC,SAAS,EAAE,CAAC,uBAAuB,CAAC;CACrC,CAAC;AAEF,MAAM,kBAAkB,GAAqC;IAC3D,OAAO,EAAE;;;;;;;;;;;sMAW2L;IAEpM,UAAU,EAAE;;;;;;;;;;;;;6OAa+N;IAE3O,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;6DAoB+C;IAE3D,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kHA8DuG;IAEhH,SAAS,EAAE;;;;;;;;;;;;;;;;;;oCAkBuB;IAElC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8JAwCkJ;IAE5J,SAAS,EAAE;;;;;;;;;;;;;;;;;oKAiBuJ;CACnK,CAAC;AASF,iEAAiE;AACjE,MAAM,UAAU,gBAAgB,CAAC,IAAqB;IACpD,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;IACnD,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;QACzD,yBAAyB,GAAG,SAAS,GAAG,GAAG,CAAC;IAC9C,MAAM,gBAAgB,GACpB,kBAAkB,CAAC,OAAO,CAAC;QAC3B,YAAY,OAAO,+EAA+E,OAAO,oBAAoB,CAAC;IAEhI,MAAM,aAAa,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;SAC9C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC;SACvC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,OAAO;;;;oBAIW,OAAO;WAChB,IAAI,CAAC,KAAK,IAAI,WAAW;iBACnB,IAAI,CAAC,WAAW,IAAI,WAAW;UACtC,IAAI,CAAC,IAAI,IAAI,OAAO;UACpB,IAAI,CAAC,IAAI,IAAI,WAAW;aACrB,IAAI,CAAC,OAAO,IAAI,WAAW;+BACT,IAAI,CAAC,OAAO,CAAC,MAAM;;;;;MAK5C,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;;;EAG/B,aAAa,IAAI,yBAAyB;;;;EAI1C,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDhB,aAAa;CACd,CAAC;AACF,CAAC;AAED,SAAS,QAAQ,CAAC,IAAY;IAC5B,IAAI,CAAC;QACH,OAAO,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACpC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/agents/run-log.js

@@ -0,0 +1,71 @@
+// Tee-style audit log of every agent run.
+//
+// We already get resume-on-failure for free via Claude's session.json (and
+// Codex's equivalent), so this log isn't load-bearing for recovery. What it
+// *does* give us:
+//
+//   - A user-readable transcript of past runs they can scroll back through.
+//   - Forensic data when something behaves weirdly (rate-limit retry order,
+//     unexpected tool calls, parse failures in the JSON stream).
+//   - Raw material for a future "replay a run in the UI" feature.
+//
+// One file per run, namespaced by phaseId, timestamped. The first line is a
+// `_liner_meta` envelope describing the run; the body is the agent's raw
+// JSONL exactly as we received it; the last line is a `_liner_close` marker
+// with the exit code and end time. Everything else (parsed events, derived
+// UI state) is reconstructable from those primitives.
+import { createWriteStream, mkdirSync } from "node:fs";
+import { join } from "node:path";
+const RUN_DIR = ".liner-runs";
+/**
+ * Open a new log file for an agent run. The directory is created lazily;
+ * no IO until the first write. Caller owns close() in both happy and
+ * cancellation paths.
+ */
+export function openRunLog(folder, taskLabel, meta) {
+    // Defense-in-depth: sanitize taskLabel so a malformed caller can't escape
+    // the .liner-runs/ directory with `..` or absolute paths.
+    const safeLabel = taskLabel.replace(/[^a-zA-Z0-9_-]/g, "-") || "task";
+    const dir = join(folder, RUN_DIR, safeLabel);
+    mkdirSync(dir, { recursive: true });
+    const startedAt = new Date().toISOString();
+    // Filenames need to be filesystem-safe on Windows too — strip colons.
+    const stamp = startedAt.replace(/:/g, "-").replace(/\..+/, "");
+    const path = join(dir, `${stamp}.jsonl`);
+    const stream = createWriteStream(path, { flags: "a" });
+    let closed = false;
+    const fullMeta = { ...meta, taskLabel: safeLabel, startedAt };
+    stream.write(JSON.stringify({ type: "_liner_meta", ...fullMeta }) + "\n", "utf8");
+    return {
+        path,
+        write(line) {
+            if (closed)
+                return;
+            if (!line)
+                return;
+            stream.write(line, "utf8");
+            if (!line.endsWith("\n"))
+                stream.write("\n", "utf8");
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            stream.end();
+        },
+    };
+}
+/**
+ * Convenience: append a final `_liner_close` marker with exit metadata before
+ * the stream is shut. Callers call this from the agent's `close` handler.
+ */
+export function closeRunLog(log, code, stderrLen) {
+    log.write(JSON.stringify({
+        type: "_liner_close",
+        exitCode: code,
+        stderrBytes: stderrLen,
+        endedAt: new Date().toISOString(),
+    }));
+    log.close();
+}
+//# sourceMappingURL=run-log.js.map

package/dist/agents/run-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-log.js","sourceRoot":"","sources":["../../src/agents/run-log.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,EAAE;AACF,2EAA2E;AAC3E,4EAA4E;AAC5E,kBAAkB;AAClB,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,iEAAiE;AACjE,kEAAkE;AAClE,EAAE;AACF,4EAA4E;AAC5E,yEAAyE;AACzE,4EAA4E;AAC5E,2EAA2E;AAC3E,sDAAsD;AAEtD,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAIjC,MAAM,OAAO,GAAG,aAAa,CAAC;AAwB9B;;;;GAIG;AACH,MAAM,UAAU,UAAU,CACxB,MAAc,EACd,SAAiB,EACjB,IAAiD;IAEjD,0EAA0E;IAC1E,0DAA0D;IAC1D,MAAM,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC;IACtE,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;IAC7C,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACpC,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC3C,sEAAsE;IACtE,MAAM,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC/D,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,QAAQ,CAAC,CAAC;IACzC,MAAM,MAAM,GAAgB,iBAAiB,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IACpE,IAAI,MAAM,GAAG,KAAK,CAAC;IAEnB,MAAM,QAAQ,GAAe,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC;IAC1E,MAAM,CAAC,KAAK,CACV,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,GAAG,QAAQ,EAAE,CAAC,GAAG,IAAI,EAC3D,MAAM,CACP,CAAC;IAEF,OAAO;QACL,IAAI;QACJ,KAAK,CAAC,IAAY;YAChB,IAAI,MAAM;gBAAE,OAAO;YACnB,IAAI,CAAC,IAAI;gBAAE,OAAO;YAClB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAAE,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACvD,CAAC;QACD,KAAK;YACH,IAAI,MAAM;gBAAE,OAAO;YACnB,MAAM,GAAG,IAAI,CAAC;YACd,MAAM,CAAC,GAAG,EAAE,CAAC;QACf,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,GAAW,EAAE,IAAmB,EAAE,SAAiB;IAC7E,GAAG,CAAC,KAAK,CACP,IAAI,CAAC,SAAS,CAAC;QACb,IAAI,EAAE,cAAc;QACpB,QAAQ,EAAE,IAAI;QACd,WAAW,EAAE,SAAS;QACtB,OAAO,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;KAClC,CAAC,CACH,CAAC;IACF,GAAG,CAAC,KAAK,EAAE,CAAC;AACd,CAAC"}

package/dist/agents/runner.js

@@ -0,0 +1,180 @@
+import { spawn } from "node:child_process";
+import { buildPhasePrompt } from "./prompts.js";
+import { LineBuffer, parseLine } from "./parsers.js";
+import { closeRunLog, openRunLog } from "./run-log.js";
+/**
+ * Spawn the configured agent CLI with a phase-specific prompt. The agent's
+ * newline-delimited JSON stdout is parsed into AgentEvents so the PhaseRunner
+ * can render tool calls / streaming text / summary as structured panes.
+ *
+ * Thin wrapper over `runAgentTask` — builds the per-phase prompt via
+ * `buildPhasePrompt` and labels the audit log with the phase id.
+ */
+export function runPhaseWithAgent(args) {
+    const prompt = buildPhasePrompt({
+        phaseId: args.phaseId,
+        project: args.project,
+        skillPath: args.skillPath,
+        tape: args.tape,
+    });
+    return runAgentTask({
+        agent: args.agent,
+        project: args.project,
+        skillPath: args.skillPath,
+        prompt,
+        taskLabel: args.phaseId,
+        resume: args.resume,
+        onEvent: args.onEvent,
+    });
+}
+/**
+ * Run a single agent task with a caller-supplied prompt. Used by methodology
+ * phases (via `runPhaseWithAgent`) and by one-off side tasks like the JTBD
+ * elicitation step in the new-mixtape wizard. The agent's stdout is parsed
+ * the same way (stream JSON → AgentEvent) so callers get tool calls + final
+ * text via the same callback interface.
+ */
+export function runAgentTask(args) {
+    const command = args.agent.bin;
+    const resume = args.resume === true;
+    const cliArgs = buildArgs(args.agent.id, args.project, args.skillPath, resume);
+    const child = spawn(command, cliArgs, {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: args.project,
+        env: { ...process.env },
+    });
+    // On resume, the previous session already contains the prompt + all prior
+    // tool-call results in context. Send a tiny continuation nudge instead of
+    // re-shipping the full prompt — that's the whole point of resume (cheaper,
+    // no re-fetching).
+    const stdinPayload = resume
+        ? "Continue from where you left off. Pick up the same task; do not re-do tool calls you already completed."
+        : args.prompt;
+    child.stdin?.write(stdinPayload, "utf8");
+    child.stdin?.end();
+    // Tee-style audit log of the raw JSONL stream. Not load-bearing (Claude's
+    // session.json already covers resume) — this gives us a per-run transcript
+    // the curator can scroll back through and a forensic record when things
+    // misbehave.
+    const log = openRunLog(args.project, args.taskLabel, {
+        agent: args.agent.id,
+        resume,
+    });
+    const buffer = new LineBuffer();
+    if (child.stdout) {
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            const lines = buffer.push(chunk);
+            for (const line of lines) {
+                log.write(line);
+                for (const event of parseLine(args.agent.id, line)) {
+                    args.onEvent(event);
+                }
+            }
+        });
+    }
+    let stderr = "";
+    if (child.stderr) {
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+            // Surface stderr as raw events so users see install/auth hints inline.
+            for (const line of chunk.split("\n")) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    args.onEvent({ kind: "raw", text: trimmed });
+                    // Record stderr in the log too — wrapped so it doesn't masquerade
+                    // as a real JSON event when the log is replayed.
+                    log.write(JSON.stringify({ type: "_liner_stderr", text: trimmed }));
+                }
+            }
+        });
+    }
+    const done = new Promise((resolve) => {
+        child.on("close", (code) => {
+            // Flush any trailing partial line.
+            for (const line of buffer.flush()) {
+                log.write(line);
+                for (const event of parseLine(args.agent.id, line)) {
+                    args.onEvent(event);
+                }
+            }
+            closeRunLog(log, code, stderr.length);
+            resolve({ code, stderr });
+        });
+        child.on("error", (e) => {
+            args.onEvent({ kind: "raw", text: `[runner error] ${e.message}` });
+            log.write(JSON.stringify({ type: "_liner_error", message: e.message }));
+            closeRunLog(log, 1, stderr.length);
+            resolve({ code: 1, stderr: e.message });
+        });
+    });
+    return {
+        cancel: () => {
+            if (!child.killed)
+                child.kill("SIGTERM");
+        },
+        done,
+    };
+}
+function buildArgs(id, project, skillPath, resume) {
+    if (id === "claude") {
+        // Stream-json requires --verbose. --include-partial-messages would give
+        // us mid-message chunking but the cost is ~10× more events; we let the
+        // assistant message arrive as one block per turn instead.
+        //
+        // Tool whitelist keeps the agent's reach scoped even with permissions
+        // skipped — Read/Write/Edit/Glob/Grep/WebFetch is exactly what the
+        // methodology needs and nothing more (no Bash, no Task).
+        //
+        // `--continue` (resume mode) picks up the most recent session in the
+        // current working directory. Since we spawn with cwd=project, "most
+        // recent session" is the one we started for this phase. The previous
+        // conversation — prompt, tool calls, partial work — stays in context.
+        const base = [
+            "-p",
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--add-dir",
+            skillPath,
+            "--dangerously-skip-permissions",
+            "--allowedTools",
+            "Read Write Edit Glob Grep WebFetch",
+        ];
+        if (resume)
+            base.push("--continue");
+        return base;
+    }
+    if (id === "codex") {
+        if (resume) {
+            // Codex's `exec resume` subcommand resumes the most recent thread.
+            return [
+                "exec",
+                "resume",
+                "--last",
+                "--cd",
+                project,
+                "--skip-git-repo-check",
+                "-s",
+                "workspace-write",
+                "--json",
+                "-",
+            ];
+        }
+        return [
+            "exec",
+            "--cd",
+            project,
+            "--add-dir",
+            skillPath,
+            "--skip-git-repo-check",
+            "-s",
+            "workspace-write",
+            "--json",
+            "-",
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=runner.js.map

package/dist/agents/runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.js","sourceRoot":"","sources":["../../src/agents/runner.ts"],"names":[],"mappings":"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"}

package/dist/agents/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/agents/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/agents/types.ts"],"names":[],"mappings":""}