@openthink/team 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 
 // src/commands/pull.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
@@ -250,6 +250,7 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 // src/lib/models.ts
 var ROLE_PIPELINE_MODEL = "claude-opus-4-7";
 var NORMALISER_MODEL = "claude-sonnet-4-6";
+var HAIKU_PRODUCT_MODEL = "claude-haiku-4-5";
 var PHASES = ["product", "spike", "implementation", "qa"];
 var DEFAULT_MODELS = {
   product: "claude-sonnet-4-6",
@@ -281,6 +282,55 @@ function resolveRoleModel(state, models) {
   if (pinned && pinned.length > 0) return pinned;
   return ROLE_PIPELINE_MODEL;
 }
+function acceptanceCriteriaIsPopulated(body) {
+  const lines = body.split("\n");
+  let inSection = false;
+  let inHtmlComment = false;
+  const numberedBullet = /^\s*\d+\.\s+\S/;
+  for (const line of lines) {
+    if (!inSection) {
+      if (/^##\s+Acceptance Criteria\s*$/.test(line)) {
+        inSection = true;
+      }
+      continue;
+    }
+    if (/^##\s+/.test(line)) return false;
+    let scan = line;
+    while (scan.length > 0) {
+      if (inHtmlComment) {
+        const close = scan.indexOf("-->");
+        if (close === -1) {
+          scan = "";
+          break;
+        }
+        scan = scan.slice(close + 3);
+        inHtmlComment = false;
+      } else {
+        const open = scan.indexOf("<!--");
+        if (open === -1) break;
+        const before = scan.slice(0, open);
+        if (numberedBullet.test(before)) return true;
+        const rest = scan.slice(open + 4);
+        const close = rest.indexOf("-->");
+        if (close === -1) {
+          inHtmlComment = true;
+          scan = "";
+          break;
+        }
+        scan = rest.slice(close + 3);
+      }
+    }
+    if (inHtmlComment) continue;
+    if (numberedBullet.test(scan)) return true;
+  }
+  return false;
+}
+function resolveModelForTicket(args) {
+  if (args.state === "triage" && args.sourceType === "manual" && args.productDownshift && acceptanceCriteriaIsPopulated(args.body)) {
+    return HAIKU_PRODUCT_MODEL;
+  }
+  return resolveRoleModel(args.state, args.models);
+}
 
 // src/lib/normalise.ts
 var SYSTEM_PROMPT = `You normalise unstructured work-item payloads (GitHub issues, Linear tickets, etc.) into well-formed product-vault tickets.
@@ -458,6 +508,7 @@ import {
 } from "fs";
 import { homedir } from "os";
 import { basename, isAbsolute, resolve, join as join2 } from "path";
+var DEFAULT_PRODUCT_DOWNSHIFT = true;
 function configDir() {
   return join2(homedir(), ".open-team");
 }
@@ -484,14 +535,28 @@ function writeConfig(config) {
     default: config.default,
     stamp: config.stamp
   };
-  if (Object.keys(config.models).length > 0) {
-    onDisk.models = config.models;
+  const onDiskModels = { ...config.models };
+  if (config.productDownshift !== DEFAULT_PRODUCT_DOWNSHIFT) {
+    onDiskModels.productDownshift = config.productDownshift;
+  }
+  if (Object.keys(onDiskModels).length > 0) {
+    onDisk.models = onDiskModels;
+  }
+  if (!config.telemetry.enabled) {
+    onDisk.telemetry = config.telemetry;
   }
   const body = JSON.stringify(onDisk, null, 2) + "\n";
   writeFileSync(configPath(), body);
 }
 function emptyConfig() {
-  return { vaults: {}, default: null, stamp: null, models: {} };
+  return {
+    vaults: {},
+    default: null,
+    stamp: null,
+    models: {},
+    productDownshift: DEFAULT_PRODUCT_DOWNSHIFT,
+    telemetry: { enabled: true }
+  };
 }
 function addVault(rawPath, options = {}) {
   const path = absolutise(rawPath);
@@ -590,9 +655,21 @@ function normalise(parsed) {
     vaults,
     default: def,
     stamp: normaliseStamp(obj.stamp),
-    models: normaliseModels(obj.models)
+    models: normaliseModels(obj.models),
+    productDownshift: normaliseProductDownshift(obj.models),
+    telemetry: normaliseTelemetry(obj.telemetry)
   };
 }
+function normaliseProductDownshift(value) {
+  if (!value || typeof value !== "object") return DEFAULT_PRODUCT_DOWNSHIFT;
+  const v = value;
+  return v.productDownshift !== false;
+}
+function normaliseTelemetry(value) {
+  if (!value || typeof value !== "object") return { enabled: true };
+  const v = value;
+  return { enabled: v.enabled !== false };
+}
 function normaliseModels(value) {
   if (!value || typeof value !== "object") return {};
   const out = {};
@@ -697,6 +774,24 @@ function seedDefaultModelsIfEmpty() {
   writeConfig(config);
   return { action: "seeded", models: config.models };
 }
+function getProductDownshift() {
+  return readConfig().productDownshift;
+}
+function setProductDownshift(enabled) {
+  const config = readConfig();
+  config.productDownshift = enabled;
+  writeConfig(config);
+  return config.productDownshift;
+}
+function getTelemetryEnabled() {
+  return readConfig().telemetry.enabled;
+}
+function setTelemetryEnabled(enabled) {
+  const config = readConfig();
+  config.telemetry = { enabled };
+  writeConfig(config);
+  return config.telemetry;
+}
 function clearModel(phase) {
   if (!isPhase(phase)) {
     throw new Error(
@@ -1275,9 +1370,54 @@ enforce: ${s.enforce ? "on" : "off"}
     const lines = PHASES.map((p) => `${p.padEnd(15)} ${m[p] ?? "(unset)"}`);
     process.stdout.write(lines.join("\n") + "\n");
   });
+  models.command("product-downshift <on|off|show>").description(
+    "Toggle the AGT-107 Haiku-downshift heuristic for well-formed manual tickets (default: on)"
+  ).action((flag) => {
+    const lower = flag.toLowerCase();
+    if (lower === "show") {
+      process.stdout.write(`${getProductDownshift() ? "on" : "off"}
+`);
+      return;
+    }
+    if (lower !== "on" && lower !== "off") {
+      process.stderr.write(
+        `oteam config models product-downshift: expected on|off|show, got "${flag}"
+`
+      );
+      process.exit(2);
+    }
+    const next = setProductDownshift(lower === "on");
+    process.stdout.write(
+      `\u2705 models.productDownshift = ${next ? "on" : "off"}
+`
+    );
+  });
+  const telemetry = new Command("telemetry").description(
+    "Manage per-phase telemetry recording (default: on)"
+  );
+  telemetry.command("set <on|off>").description("Turn per-phase telemetry recording on or off").action((flag) => {
+    const lower = flag.toLowerCase();
+    if (lower !== "on" && lower !== "off") {
+      process.stderr.write(
+        `oteam config telemetry set: expected on|off, got "${flag}"
+`
+      );
+      process.exit(2);
+    }
+    const next = setTelemetryEnabled(lower === "on");
+    process.stdout.write(
+      `\u2705 telemetry ${next.enabled ? "on" : "off"}
+`
+    );
+  });
+  telemetry.command("show").description("Print whether telemetry recording is on").action(() => {
+    process.stdout.write(`${getTelemetryEnabled() ? "on" : "off"}
+`);
+  });
   config.addCommand(vault);
   config.addCommand(stamp);
   config.addCommand(models);
+  config.addCommand(telemetry);
   return config;
 }
 function expectPhase(value) {
@@ -1961,18 +2101,345 @@ function openInEditor(path) {
   }
 }
 
-// src/commands/ticket.ts
+// src/commands/telemetry.ts
 import { Command as Command4 } from "commander";
-import { existsSync as existsSync7, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+
+// src/lib/telemetry.ts
+import {
+  appendFileSync,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync7
+} from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join10 } from "path";
+
+// src/lib/claude-session.ts
+import { readFileSync as readFileSync6 } from "fs";
 import { join as join9 } from "path";
+function encodeProjectDir(cwd) {
+  return cwd.replace(/\//g, "-");
+}
+function findSessionFile(claudeConfigDir, cwd, sessionId) {
+  return join9(
+    claudeConfigDir,
+    "projects",
+    encodeProjectDir(cwd),
+    `${sessionId}.jsonl`
+  );
+}
+function parseSessionFile(path) {
+  let raw;
+  try {
+    raw = readFileSync6(path, "utf8");
+  } catch {
+    return { tokens: {}, outcome: null };
+  }
+  return parseSessionJsonl(raw);
+}
+function parseSessionJsonl(raw) {
+  const tokens = {};
+  let lastAssistantText = "";
+  for (const line of raw.split("\n")) {
+    if (line.length === 0) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!entry || typeof entry !== "object") continue;
+    const e = entry;
+    if (e.type !== "assistant") continue;
+    const message = e.message;
+    if (!message || typeof message !== "object") continue;
+    const m = message;
+    if (m.usage && typeof m.usage === "object") {
+      const u = m.usage;
+      addIfFinite(tokens, "input", u.input_tokens);
+      addIfFinite(tokens, "output", u.output_tokens);
+      addIfFinite(tokens, "cache-write", u.cache_creation_input_tokens);
+      addIfFinite(tokens, "cache-read", u.cache_read_input_tokens);
+    }
+    const text = extractAssistantText(m.content);
+    if (text.length > 0) lastAssistantText = text;
+  }
+  return { tokens, outcome: detectOutcome(lastAssistantText) };
+}
+function extractAssistantText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let out = "";
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const p = part;
+    if (p.type === "text" && typeof p.text === "string") {
+      out += (out.length > 0 ? "\n" : "") + p.text;
+    }
+  }
+  return out;
+}
+function detectOutcome(text) {
+  if (text.includes("\u2705 DONE")) return "done";
+  if (text.includes("\u23F8\uFE0F PAUSED")) return "paused";
+  if (text.includes("\u{1F6D1} BLOCKED")) return "failed";
+  return null;
+}
+function addIfFinite(target, key, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return;
+  target[key] = (target[key] ?? 0) + value;
+}
+
+// src/lib/telemetry.ts
+function telemetryDir() {
+  const override = process.env.OTEAM_TELEMETRY_DIR;
+  if (override && override.length > 0) return override;
+  return join10(homedir4(), ".open-team", "telemetry");
+}
+function runsPath(dir = telemetryDir()) {
+  return join10(dir, "runs.jsonl");
+}
+function recordPhase(input) {
+  try {
+    if (!getTelemetryEnabled()) return;
+    const endedAt = input.endedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    const wallClockMs = computeWallClockMs(input.startedAt, endedAt);
+    const sessionFile = findSessionFile(
+      resolveClaudeConfigDir(),
+      input.cwd,
+      input.sessionId
+    );
+    let tokens = {};
+    let markerOutcome = null;
+    if (existsSync7(sessionFile)) {
+      const parsed = parseSessionFile(sessionFile);
+      tokens = parsed.tokens;
+      markerOutcome = parsed.outcome;
+    }
+    const outcome = input.exitCode !== 0 ? "failed" : markerOutcome ?? "unknown";
+    const line = {
+      ticket: input.ticket,
+      phase: input.phase,
+      model: input.model,
+      "started-at": input.startedAt,
+      "ended-at": endedAt,
+      "wall-clock-ms": wallClockMs,
+      tokens,
+      outcome
+    };
+    const dir = telemetryDir();
+    mkdirSync6(dir, { recursive: true });
+    appendFileSync(runsPath(dir), JSON.stringify(line) + "\n");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`oteam: telemetry record failed: ${msg}
+`);
+  }
+}
+function resolveClaudeConfigDir() {
+  const env = process.env.CLAUDE_CONFIG_DIR;
+  if (env && env.length > 0) return env;
+  return join10(homedir4(), ".claude");
+}
+function computeWallClockMs(startedAt, endedAt) {
+  const startMs = Date.parse(startedAt);
+  const endMs = Date.parse(endedAt);
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) return 0;
+  return Math.max(0, endMs - startMs);
+}
+function readRuns(dir = telemetryDir()) {
+  const path = runsPath(dir);
+  if (!existsSync7(path)) return [];
+  const raw = readFileSync7(path, "utf8");
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (line.length === 0) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && typeof parsed === "object") out.push(parsed);
+    } catch {
+    }
+  }
+  return out;
+}
+function summarize(runs, filter = {}) {
+  const filtered = applyFilter(runs, filter);
+  const buckets = /* @__PURE__ */ new Map();
+  for (const r of filtered) {
+    const key = `${r.phase} ${r.model}`;
+    const bucket = buckets.get(key) ?? { phase: r.phase, model: r.model, rows: [] };
+    bucket.rows.push(r);
+    buckets.set(key, bucket);
+  }
+  const rows = [];
+  for (const bucket of buckets.values()) {
+    rows.push({
+      phase: bucket.phase,
+      model: bucket.model,
+      count: bucket.rows.length,
+      meanWallClockMs: meanWallClock(bucket.rows),
+      meanTokens: meanTokens(bucket.rows)
+    });
+  }
+  rows.sort(
+    (a, b) => a.phase.localeCompare(b.phase) || a.model.localeCompare(b.model)
+  );
+  return rows;
+}
+function applyFilter(runs, filter) {
+  let cutoffMs = null;
+  if (typeof filter.days === "number" && filter.days > 0) {
+    cutoffMs = Date.now() - filter.days * 24 * 60 * 60 * 1e3;
+  }
+  return runs.filter((r) => {
+    if (filter.phase && r.phase !== filter.phase) return false;
+    if (filter.model && r.model !== filter.model) return false;
+    if (cutoffMs !== null) {
+      const t = Date.parse(r["started-at"]);
+      if (!Number.isFinite(t) || t < cutoffMs) return false;
+    }
+    return true;
+  });
+}
+function meanWallClock(rows) {
+  if (rows.length === 0) return 0;
+  const sum = rows.reduce((acc, r) => acc + (r["wall-clock-ms"] ?? 0), 0);
+  return Math.round(sum / rows.length);
+}
+function meanTokens(rows) {
+  const keys = [
+    "input",
+    "output",
+    "cache-read",
+    "cache-write"
+  ];
+  const out = {};
+  for (const k of keys) {
+    let sum = 0;
+    let n = 0;
+    for (const r of rows) {
+      const v = r.tokens?.[k];
+      if (typeof v === "number" && Number.isFinite(v)) {
+        sum += v;
+        n += 1;
+      }
+    }
+    if (n > 0) out[k] = Math.round(sum / n);
+  }
+  return out;
+}
+function tail(n, dir = telemetryDir()) {
+  const all = readRuns(dir);
+  if (n <= 0) return [];
+  return all.slice(-n);
+}
+
+// src/commands/telemetry.ts
+function buildTelemetryCommand() {
+  const telemetry = new Command4("telemetry").description(
+    "Per-phase wall-clock + token telemetry for role-pipeline spawns"
+  );
+  telemetry.command("summary").description(
+    "Aggregate runs.jsonl by phase \xD7 model (count, mean wall-clock, mean tokens)"
+  ).option("--days <n>", "Only include runs from the last N days", parsePositiveInt).option("--phase <name>", "Filter by phase (product|spike|implementation|qa)").option("--model <id>", "Filter by resolved model id").action(
+    (opts) => {
+      const runs = readRuns();
+      if (runs.length === 0) {
+        process.stdout.write(
+          `(no telemetry yet \u2014 ${telemetryDir()}/runs.jsonl is empty or missing)
+`
+        );
+        return;
+      }
+      const rows = summarize(runs, opts);
+      if (rows.length === 0) {
+        process.stdout.write("(no rows match filters)\n");
+        return;
+      }
+      process.stdout.write(formatSummary(rows) + "\n");
+    }
+  );
+  telemetry.command("tail").description("Print the last N telemetry lines (default 20)").option("-n, --count <n>", "How many lines to print", parsePositiveInt, 20).action((opts) => {
+    const lines = tail(opts.count);
+    if (lines.length === 0) {
+      process.stdout.write(
+        `(no telemetry yet \u2014 ${telemetryDir()}/runs.jsonl is empty or missing)
+`
+      );
+      return;
+    }
+    for (const line of lines) {
+      process.stdout.write(JSON.stringify(line) + "\n");
+    }
+  });
+  telemetry.command("record", { hidden: true }).description("(internal) Record one phase's telemetry line").requiredOption("--ticket <id>", "Ticket id (e.g. AGT-108)").requiredOption("--phase <name>", "Phase name (product|spike|implementation|qa)").requiredOption("--model <id>", "Resolved model id passed to claude").requiredOption("--session <uuid>", "Session UUID passed to `claude --session-id`").requiredOption("--started-at <iso>", "ISO timestamp captured before spawning claude").requiredOption("--exit-code <n>", "claude's exit code", parseSignedInt).option("--cwd <path>", "Working directory the spawn ran in (defaults to $PWD)").action(
+    (opts) => {
+      recordPhase({
+        ticket: opts.ticket,
+        phase: opts.phase,
+        model: opts.model,
+        sessionId: opts.session,
+        startedAt: opts.startedAt,
+        exitCode: opts.exitCode,
+        cwd: opts.cwd ?? process.cwd()
+      });
+    }
+  );
+  return telemetry;
+}
+function parsePositiveInt(raw) {
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) {
+    process.stderr.write(`oteam telemetry: expected a positive integer, got "${raw}"
+`);
+    process.exit(2);
+  }
+  return n;
+}
+function parseSignedInt(raw) {
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n)) {
+    process.stderr.write(`oteam telemetry: expected an integer, got "${raw}"
+`);
+    process.exit(2);
+  }
+  return n;
+}
+function formatSummary(rows) {
+  const headers = ["phase", "model", "count", "mean_ms", "mean_in", "mean_out", "mean_cache_r", "mean_cache_w"];
+  const data = rows.map((r) => [
+    r.phase,
+    r.model,
+    String(r.count),
+    String(r.meanWallClockMs),
+    formatTokenField(r.meanTokens, "input"),
+    formatTokenField(r.meanTokens, "output"),
+    formatTokenField(r.meanTokens, "cache-read"),
+    formatTokenField(r.meanTokens, "cache-write")
+  ]);
+  const widths = headers.map(
+    (h, i) => Math.max(h.length, ...data.map((row) => (row[i] ?? "").length))
+  );
+  const fmt = (cells) => cells.map((c, i) => c.padEnd(widths[i] ?? 0)).join("  ").trimEnd();
+  return [fmt(headers), ...data.map(fmt)].join("\n");
+}
+function formatTokenField(tokens, key) {
+  const v = tokens[key];
+  return typeof v === "number" ? String(v) : "-";
+}
+
+// src/commands/ticket.ts
+import { Command as Command5 } from "commander";
+import { existsSync as existsSync8, mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join11 } from "path";
 function runTicketNew(opts) {
   const title = opts.title.trim();
   if (title.length === 0) {
     throw new Error("oteam ticket new: <title> must not be empty");
   }
   const vault = resolveVaultPath({ flagValue: opts.vault });
-  const triageDir = join9(vault, "tickets", "triage");
-  mkdirSync6(triageDir, { recursive: true });
+  const triageDir = join11(vault, "tickets", "triage");
+  mkdirSync7(triageDir, { recursive: true });
   const id = nextTicketID(vault);
   const slug = slugify(title);
   if (slug.length === 0) {
@@ -1980,8 +2447,8 @@ function runTicketNew(opts) {
       `oteam ticket new: title "${title}" produced an empty slug \u2014 use a title with at least one alphanumeric character`
     );
   }
-  const target = join9(triageDir, `${id}-${slug}.md`);
-  if (existsSync7(target)) {
+  const target = join11(triageDir, `${id}-${slug}.md`);
+  if (existsSync8(target)) {
     throw new Error(
       `oteam ticket new: target already exists at ${target} \u2014 ID scan collision`
     );
@@ -2003,7 +2470,7 @@ function collectLabel(value, prev = []) {
   return [...prev, value];
 }
 function buildTicketCommand() {
-  const ticket = new Command4("ticket").description(
+  const ticket = new Command5("ticket").description(
     "Create vault tickets directly (without an external source)"
   );
   ticket.command("new <title>").description(
@@ -2036,13 +2503,14 @@ function buildTicketCommand() {
 
 // src/role-pipeline/runner.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { writeFileSync as writeFileSync7 } from "fs";
+import { randomUUID } from "crypto";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir } from "os";
-import { resolve as resolve4, basename as basename5, dirname as dirname2, join as join12 } from "path";
+import { resolve as resolve4, basename as basename5, dirname as dirname2, join as join14 } from "path";
 
 // src/lib/kitty.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync8, readdirSync as readdirSync5 } from "fs";
+import { existsSync as existsSync9, readdirSync as readdirSync5 } from "fs";
 var SOCKET_BASENAME = "kitty-claudini";
 var KNOWN_INSTANCES = ["personal", "work"];
 function isMacOS() {
@@ -2085,7 +2553,7 @@ function findKittySocket(kittyPath, preferring) {
     candidates.push(...pidSuffixed);
   }
   for (const path of candidates) {
-    if (!existsSync8(path)) continue;
+    if (!existsSync9(path)) continue;
     const socket = `unix:${path}`;
     const r = spawnSync2(kittyPath, ["@", "--to", socket, "ls"], {
       encoding: "utf8"
@@ -2151,9 +2619,9 @@ function shellEscape(s) {
 }
 
 // src/lib/workspace.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, readdirSync as readdirSync6, rmSync } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readdirSync as readdirSync6, rmSync } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
-import { basename as basename4, join as join10 } from "path";
+import { basename as basename4, join as join12 } from "path";
 function buildGithubUrl(repoSlug) {
   return `git@github.com:${repoSlug}.git`;
 }
@@ -2191,12 +2659,12 @@ function prepareAgentWorkspace(opts) {
     );
   }
   const root = opts.rootDir ?? WORKSPACE_ROOT;
-  mkdirSync7(root, { recursive: true });
+  mkdirSync8(root, { recursive: true });
   if (opts.activeTicketIds) gcOrphanWorkspaces(root, opts.activeTicketIds);
-  const ticketDir = join10(root, opts.ticketId.toLowerCase());
-  const repoDir = join10(ticketDir, "repo");
+  const ticketDir = join12(root, opts.ticketId.toLowerCase());
+  const repoDir = join12(ticketDir, "repo");
   rmSync(ticketDir, { recursive: true, force: true });
-  mkdirSync7(ticketDir, { recursive: true });
+  mkdirSync8(ticketDir, { recursive: true });
   const repoBasename = basename4(opts.repoSlug);
   const cloneRunner = opts.cloneRunner ?? defaultCloneRunner;
   if (opts.mode === "github") {
@@ -2247,7 +2715,7 @@ var defaultCloneRunner = (url, dest) => {
   };
 };
 function gcOrphanWorkspaces(root, activeTicketIds) {
-  if (!existsSync9(root)) return [];
+  if (!existsSync10(root)) return [];
   const removed = [];
   let entries;
   try {
@@ -2258,7 +2726,7 @@ function gcOrphanWorkspaces(root, activeTicketIds) {
   for (const name of entries) {
     if (!ORPHAN_DIR_RE.test(name)) continue;
     if (activeTicketIds.has(name)) continue;
-    const target = join10(root, name);
+    const target = join12(root, name);
     try {
       rmSync(target, { recursive: true, force: true });
       removed.push(target);
@@ -2269,22 +2737,22 @@ function gcOrphanWorkspaces(root, activeTicketIds) {
 }
 
 // src/role-pipeline/install-slash-command.ts
-import { copyFileSync, existsSync as existsSync10, mkdirSync as mkdirSync8, readdirSync as readdirSync7, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname, join as join11 } from "path";
+import { copyFileSync, existsSync as existsSync11, mkdirSync as mkdirSync9, readdirSync as readdirSync7, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname, join as join13 } from "path";
 import { fileURLToPath } from "url";
 var moduleDir = dirname(fileURLToPath(import.meta.url));
-var BUNDLED_PROMPT = join11(moduleDir, "assign-ticket.md");
+var BUNDLED_PROMPT = join13(moduleDir, "assign-ticket.md");
 function installRolePipelineSlashCommand() {
-  if (!existsSync10(BUNDLED_PROMPT)) return;
-  const bundled = readFileSync6(BUNDLED_PROMPT);
+  if (!existsSync11(BUNDLED_PROMPT)) return;
+  const bundled = readFileSync8(BUNDLED_PROMPT);
   const targets = resolveTargetDirs();
   for (const dir of targets) {
     try {
-      mkdirSync8(dir, { recursive: true });
-      const target = join11(dir, "assign-ticket.md");
-      if (existsSync10(target)) {
-        const current = readFileSync6(target);
+      mkdirSync9(dir, { recursive: true });
+      const target = join13(dir, "assign-ticket.md");
+      if (existsSync11(target)) {
+        const current = readFileSync8(target);
         if (current.equals(bundled)) continue;
       }
       copyFileSync(BUNDLED_PROMPT, target);
@@ -2293,23 +2761,23 @@ function installRolePipelineSlashCommand() {
   }
 }
 function resolveTargetDirs() {
-  const home = homedir4();
+  const home = homedir5();
   const dirs = /* @__PURE__ */ new Set();
-  dirs.add(join11(home, ".claude", "commands"));
+  dirs.add(join13(home, ".claude", "commands"));
   const configDir2 = process.env.CLAUDE_CONFIG_DIR;
   if (configDir2 && configDir2.length > 0) {
-    dirs.add(join11(configDir2, "commands"));
+    dirs.add(join13(configDir2, "commands"));
   }
   try {
     for (const name of readdirSync7(home)) {
       if (!name.startsWith(".claude-")) continue;
-      const candidate = join11(home, name);
+      const candidate = join13(home, name);
       let isDir = false;
       try {
         isDir = statSync4(candidate).isDirectory();
       } catch {
       }
-      if (isDir) dirs.add(join11(candidate, "commands"));
+      if (isDir) dirs.add(join13(candidate, "commands"));
     }
   } catch {
   }
@@ -2382,10 +2850,34 @@ async function assignTicket(opts) {
     }
   }
   const projectContext = loadProjectContext(resolvedVault.path, ticket.project);
-  const model = resolveRoleModel(ticket.state, config.models);
+  const ticketBody = readTicketBody(ticketPath);
+  const model = resolveModelForTicket({
+    state: ticket.state,
+    sourceType: ticket.source.type,
+    body: ticketBody,
+    productDownshift: config.productDownshift,
+    models: config.models
+  });
+  const haikuDownshift = model === HAIKU_PRODUCT_MODEL && ticket.state === "triage";
+  const systemPrompt = composeSystemPrompt(ticket.id, projectContext, haikuDownshift);
+  const phase = phaseForState(ticket.state);
+  const telemetry = phase !== null && getTelemetryEnabled() ? {
+    ticketId: ticket.id,
+    phase,
+    sessionId: randomUUID(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  } : null;
   const kittyPath = !opts.workInline && isMacOS() ? findKittyBinary() : null;
   if (!kittyPath) {
-    runInline(claudePath, ticketPath, resolvedVault.path, projectContext, workspace, model);
+    runInline(
+      claudePath,
+      ticketPath,
+      resolvedVault.path,
+      systemPrompt,
+      workspace,
+      model,
+      telemetry
+    );
     return;
   }
   const monitored = opts.monitoredOrgs ?? readMonitoredOrgsFromEnv();
@@ -2396,7 +2888,15 @@ async function assignTicket(opts) {
       `oteam assign: no kitty socket reachable (preferring "${preferring}"); falling back to inline run.
 `
     );
-    runInline(claudePath, ticketPath, resolvedVault.path, projectContext, workspace, model);
+    runInline(
+      claudePath,
+      ticketPath,
+      resolvedVault.path,
+      systemPrompt,
+      workspace,
+      model,
+      telemetry
+    );
     return;
   }
   const cwd = workspace?.path ?? dirname2(ticketPath);
@@ -2410,8 +2910,18 @@ async function assignTicket(opts) {
   const escapedTicket = shellEscape(ticketPath);
   const slashPrompt = `/assign-ticket ${escapedTicket}`;
   const escapedPrompt = shellEscape(slashPrompt);
-  const projectFlag = projectContext ? ` --append-system-prompt "$(cat '${shellEscape(projectContext.tmpFile)}')"` : "";
-  const shellCmd = `${envPrefix}exec '${escapedClaude}' --dangerously-skip-permissions --model ${shellEscape(model)}${projectFlag} '${escapedPrompt}'`;
+  const projectFlag = systemPrompt ? ` --append-system-prompt "$(cat '${shellEscape(systemPrompt.tmpFile)}')"` : "";
+  const sessionFlag = telemetry ? ` --session-id '${shellEscape(telemetry.sessionId)}'` : "";
+  const claudeCmd = `'${escapedClaude}' --dangerously-skip-permissions --model ${shellEscape(model)}${sessionFlag}${projectFlag} '${escapedPrompt}'`;
+  const telemetryTail = telemetry ? buildTelemetryTail({
+    oteamPath: findToolOnPath("oteam") ?? "oteam",
+    ticketId: telemetry.ticketId,
+    phase: telemetry.phase,
+    model,
+    sessionId: telemetry.sessionId,
+    startedAt: telemetry.startedAt
+  }) : "";
+  const shellCmd = `${envPrefix}${claudeCmd}${telemetryTail}`;
   const result = kittyLaunch({
     socket,
     title,
@@ -2425,16 +2935,32 @@ async function assignTicket(opts) {
     );
   }
 }
-function runInline(claudePath, ticketPath, vaultPath, projectContext, workspace, model) {
+function buildTelemetryTail(input) {
+  const oteam = `'${shellEscape(input.oteamPath)}'`;
+  const args = [
+    `--ticket '${shellEscape(input.ticketId)}'`,
+    `--phase '${shellEscape(input.phase)}'`,
+    `--model '${shellEscape(input.model)}'`,
+    `--session '${shellEscape(input.sessionId)}'`,
+    `--started-at '${shellEscape(input.startedAt)}'`,
+    `--exit-code "$EC"`
+  ].join(" ");
+  return `; EC=$?; ${oteam} telemetry record ${args} >/dev/null 2>&1 || true; exit "$EC"`;
+}
+function runInline(claudePath, ticketPath, vaultPath, systemPrompt, workspace, model, telemetry) {
   const args = [
     "--dangerously-skip-permissions",
     "--model",
     model
   ];
-  if (projectContext) {
-    args.push("--append-system-prompt", projectContext.content);
+  if (telemetry) {
+    args.push("--session-id", telemetry.sessionId);
+  }
+  if (systemPrompt) {
+    args.push("--append-system-prompt", systemPrompt.content);
   }
   args.push(`/assign-ticket ${ticketPath}`);
+  const cwd = workspace?.path ?? process.cwd();
   const r = spawnSync4(
     claudePath,
     args,
@@ -2444,6 +2970,17 @@ function runInline(claudePath, ticketPath, vaultPath, projectContext, workspace,
       env: { ...process.env, PRODUCT_VAULT_PATH: vaultPath }
     }
   );
+  if (telemetry) {
+    recordPhase({
+      ticket: telemetry.ticketId,
+      phase: telemetry.phase,
+      model,
+      sessionId: telemetry.sessionId,
+      startedAt: telemetry.startedAt,
+      exitCode: r.status ?? -1,
+      cwd
+    });
+  }
   if (r.status != null && r.status !== 0) process.exit(r.status);
 }
 function collectActiveTicketIds(vaultPath) {
@@ -2466,12 +3003,39 @@ function loadProjectContext(vaultPath, projectId) {
     );
     return null;
   }
-  const content = formatProjectContextForPrompt(project);
-  const safeId = projectId.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const tmpFile = join12(tmpdir(), `oteam-project-${safeId}.md`);
+  return formatProjectContextForPrompt(project);
+}
+function composeSystemPrompt(ticketId, projectContext, haikuDownshift) {
+  const parts = [];
+  if (projectContext) parts.push(projectContext);
+  if (haikuDownshift) parts.push(haikuDownshiftPromptHint());
+  if (parts.length === 0) return null;
+  const content = parts.join("\n\n");
+  const safeId = ticketId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const tmpFile = join14(tmpdir(), `oteam-prompt-${safeId}.md`);
   writeFileSync7(tmpFile, content, "utf8");
   return { tmpFile, content };
 }
+function haikuDownshiftPromptHint() {
+  return [
+    "# Product agent: haiku-downshift heuristic active",
+    "",
+    "AGT-107: this ticket is a well-formed manual ticket (source.type=manual + populated `## Acceptance Criteria`), so the runner spawned you on Haiku 4.5 instead of the configured Product model. The heuristic exists to handle structural-cleanup cases cheaply; full synthesis still belongs on the configured Product model.",
+    "",
+    "When you advance the ticket, write the comment header as:",
+    "",
+    "    ### YYYY-MM-DD \u2014 Product agent (haiku-downshift)",
+    "",
+    "instead of the standard `### YYYY-MM-DD \u2014 Product agent`. That makes the heuristic visible in the ticket's audit trail."
+  ].join("\n");
+}
+function readTicketBody(path) {
+  try {
+    return readFileSync9(path, "utf8");
+  } catch {
+    return "";
+  }
+}
 function findToolOnPath(name) {
   const r = spawnSync4("/usr/bin/env", ["which", name], { encoding: "utf8" });
   if (r.status !== 0) return null;
@@ -2485,7 +3049,7 @@ function readMonitoredOrgsFromEnv() {
 }
 
 // src/index.ts
-var program = new Command5();
+var program = new Command6();
 program.name("oteam").description(
   "Source-agnostic vault-driven role pipeline for spawning Claude agents against tickets"
 ).version("0.0.1");
@@ -2564,6 +3128,7 @@ program.command("archive <ticket-id>").description("Move a done ticket to archiv
 program.addCommand(buildConfigCommand());
 program.addCommand(buildInitCommand());
 program.addCommand(buildProjectCommand());
+program.addCommand(buildTelemetryCommand());
 program.addCommand(buildTicketCommand());
 program.parseAsync(process.argv).catch((err) => {
   process.stderr.write(`oteam: ${err.message}