@openthink/team 0.0.1 → 0.0.3

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,37 @@ 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 PHASES = ["product", "spike", "implementation", "qa"];
+var DEFAULT_MODELS = {
+  product: "claude-sonnet-4-6",
+  spike: "claude-opus-4-7",
+  implementation: "claude-sonnet-4-6",
+  qa: "claude-sonnet-4-6"
+};
+function isPhase(value) {
+  return PHASES.includes(value);
+}
+function phaseForState(state) {
+  switch (state) {
+    case "triage":
+      return "product";
+    case "refined":
+      return "spike";
+    case "in-progress":
+      return "implementation";
+    case "qa":
+      return "qa";
+    default:
+      return null;
+  }
+}
+function resolveRoleModel(state, models) {
+  const phase = phaseForState(state);
+  if (!phase) return ROLE_PIPELINE_MODEL;
+  const pinned = models?.[phase];
+  if (pinned && pinned.length > 0) return pinned;
+  return ROLE_PIPELINE_MODEL;
+}
 
 // src/lib/normalise.ts
 var SYSTEM_PROMPT = `You normalise unstructured work-item payloads (GitHub issues, Linear tickets, etc.) into well-formed product-vault tickets.
@@ -435,7 +466,7 @@ function configPath() {
 }
 function readConfig() {
   const path = configPath();
-  if (!existsSync(path)) return { vaults: {}, default: null };
+  if (!existsSync(path)) return emptyConfig();
   const raw = readFileSync(path, "utf8");
   let parsed;
   try {
@@ -448,9 +479,29 @@ function readConfig() {
 }
 function writeConfig(config) {
   mkdirSync(configDir(), { recursive: true });
-  const body = JSON.stringify(config, null, 2) + "\n";
+  const onDisk = {
+    vaults: config.vaults,
+    default: config.default,
+    stamp: config.stamp
+  };
+  if (Object.keys(config.models).length > 0) {
+    onDisk.models = config.models;
+  }
+  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: {},
+    telemetry: { enabled: true }
+  };
+}
 function addVault(rawPath, options = {}) {
   const path = absolutise(rawPath);
   const config = readConfig();
@@ -533,7 +584,9 @@ function findVaultRootForPath(filePath, config = readConfig()) {
   return null;
 }
 function normalise(parsed) {
-  if (!parsed || typeof parsed !== "object") return { vaults: {}, default: null };
+  if (!parsed || typeof parsed !== "object") {
+    return emptyConfig();
+  }
   const obj = parsed;
   const vaults = {};
   if (obj.vaults && typeof obj.vaults === "object") {
@@ -542,7 +595,146 @@ function normalise(parsed) {
     }
   }
   const def = typeof obj.default === "string" && obj.default in vaults ? obj.default : null;
-  return { vaults, default: def };
+  return {
+    vaults,
+    default: def,
+    stamp: normaliseStamp(obj.stamp),
+    models: normaliseModels(obj.models),
+    telemetry: normaliseTelemetry(obj.telemetry)
+  };
+}
+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 = {};
+  for (const [phase, modelId] of Object.entries(value)) {
+    if (!isPhase(phase)) continue;
+    if (typeof modelId !== "string") continue;
+    const trimmed = modelId.trim();
+    if (trimmed.length === 0) continue;
+    out[phase] = trimmed;
+  }
+  return out;
+}
+function normaliseStamp(value) {
+  if (value == null) return null;
+  if (typeof value !== "object") return null;
+  const s = value;
+  if (typeof s.host !== "string") return null;
+  const host = s.host.trim();
+  if (host.length === 0) return null;
+  return { host: stripTrailingSlash(host), enforce: s.enforce === true };
+}
+function stripTrailingSlash(s) {
+  return s.replace(/\/+$/, "");
+}
+function getStampConfig() {
+  return readConfig().stamp;
+}
+function setStampHost(host) {
+  const trimmed = host.trim();
+  if (trimmed.length === 0) {
+    throw new Error("stamp host cannot be empty \u2014 pass a value like ssh://git@host:port");
+  }
+  const config = readConfig();
+  const next = {
+    host: stripTrailingSlash(trimmed),
+    enforce: config.stamp?.enforce ?? false
+  };
+  config.stamp = next;
+  writeConfig(config);
+  return next;
+}
+function setStampEnforce(enforce) {
+  const config = readConfig();
+  if (enforce && (!config.stamp || config.stamp.host.length === 0)) {
+    throw new Error(
+      "cannot set stamp.enforce on with no stamp.host \u2014 run 'oteam config stamp set --host <url>' first"
+    );
+  }
+  const next = {
+    host: config.stamp?.host ?? "",
+    enforce
+  };
+  config.stamp = next;
+  writeConfig(config);
+  return next;
+}
+function setStamp(input) {
+  const trimmed = input.host.trim();
+  if (trimmed.length === 0) {
+    throw new Error("stamp host cannot be empty \u2014 pass a value like ssh://git@host:port");
+  }
+  const next = {
+    host: stripTrailingSlash(trimmed),
+    enforce: input.enforce
+  };
+  const config = readConfig();
+  config.stamp = next;
+  writeConfig(config);
+  return next;
+}
+function clearStamp() {
+  const config = readConfig();
+  config.stamp = null;
+  writeConfig(config);
+}
+function getModels() {
+  return readConfig().models;
+}
+function setModel(phase, modelId) {
+  const trimmed = modelId.trim();
+  if (trimmed.length === 0) {
+    throw new Error(
+      `model id for phase "${phase}" cannot be empty \u2014 pass a non-empty string`
+    );
+  }
+  if (!isPhase(phase)) {
+    throw new Error(
+      `unknown phase "${phase}" \u2014 supported: ${PHASES.join(", ")}`
+    );
+  }
+  const config = readConfig();
+  config.models = { ...config.models, [phase]: trimmed };
+  writeConfig(config);
+  return config.models;
+}
+function seedDefaultModelsIfEmpty() {
+  const config = readConfig();
+  if (Object.keys(config.models).length > 0) {
+    return { action: "preserved", models: config.models };
+  }
+  config.models = { ...DEFAULT_MODELS };
+  writeConfig(config);
+  return { action: "seeded", models: config.models };
+}
+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(
+      `unknown phase "${phase}" \u2014 supported: ${PHASES.join(", ")}`
+    );
+  }
+  const config = readConfig();
+  if (phase in config.models) {
+    const next = { ...config.models };
+    delete next[phase];
+    config.models = next;
+    writeConfig(config);
+  }
+  return config.models;
 }
 function findEntry(config, nameOrPath) {
   if (config.vaults[nameOrPath]) return nameOrPath;
@@ -1031,26 +1223,213 @@ function buildConfigCommand() {
       return;
     }
     process.stdout.write(`${def}
+`);
+  });
+  const stamp = new Command("stamp").description(
+    "Manage stamp-server integration (host + enforce flag)"
+  );
+  const stampSet = new Command("set").description("Set the stamp host and/or the enforce flag").option("--host <url>", "Stamp server host (e.g. ssh://git@host:port)").option("--enforce <on|off>", "Refuse repos not registered on stamp").action((opts) => {
+    if (!opts.host && !opts.enforce) {
+      process.stderr.write(
+        "oteam config stamp set: pass --host <url> and/or --enforce <on|off>\n"
+      );
+      process.exit(2);
+    }
+    if (opts.host) {
+      const next = setStampHost(opts.host);
+      process.stdout.write(
+        `\u2705 stamp.host = ${next.host} (enforce=${next.enforce ? "on" : "off"})
+`
+      );
+    }
+    if (opts.enforce) {
+      const flag = opts.enforce.toLowerCase();
+      if (flag !== "on" && flag !== "off") {
+        process.stderr.write(
+          `oteam config stamp set: --enforce expects on|off, got "${opts.enforce}"
+`
+        );
+        process.exit(2);
+      }
+      const next = setStampEnforce(flag === "on");
+      process.stdout.write(
+        `\u2705 stamp.enforce = ${next.enforce ? "on" : "off"} (host=${next.host || "(unset)"})
+`
+      );
+    }
+  });
+  const stampClear = new Command("clear").description("Remove the stamp block from oteam config").action(() => {
+    clearStamp();
+    process.stdout.write("\u2705 stamp config cleared\n");
+  });
+  const stampShow = new Command("show").description("Print the current stamp config").action(() => {
+    const s = getStampConfig();
+    if (!s) {
+      process.stdout.write("(stamp not configured)\n");
+      return;
+    }
+    process.stdout.write(`host: ${s.host}
+enforce: ${s.enforce ? "on" : "off"}
+`);
+  });
+  stamp.addCommand(stampSet);
+  stamp.addCommand(stampClear);
+  stamp.addCommand(stampShow);
+  const models = new Command("models").description(
+    "Per-phase model overrides for the role pipeline (product|spike|implementation|qa)"
+  );
+  models.command("set <phase> <model-id>").description(
+    `Pin a model id for one phase (phase: ${PHASES.join("|")})`
+  ).action((phaseRaw, modelId) => {
+    const phase = expectPhase(phaseRaw);
+    const next = setModel(phase, modelId);
+    process.stdout.write(
+      `\u2705 models.${phase} = ${next[phase]}
+`
+    );
+  });
+  models.command("clear <phase>").description("Remove the override for one phase (falls back to the role-pipeline default)").action((phaseRaw) => {
+    const phase = expectPhase(phaseRaw);
+    clearModel(phase);
+    process.stdout.write(`\u2705 models.${phase} cleared
+`);
+  });
+  models.command("show").description("Print the current per-phase model overrides").action(() => {
+    const m = getModels();
+    const lines = PHASES.map((p) => `${p.padEnd(15)} ${m[p] ?? "(unset)"}`);
+    process.stdout.write(lines.join("\n") + "\n");
+  });
+  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) {
+  if (!isPhase(value)) {
+    process.stderr.write(
+      `oteam config models: unknown phase "${value}" \u2014 supported: ${PHASES.join(", ")}
+`
+    );
+    process.exit(2);
+  }
+  return value;
+}
 
 // src/commands/init.ts
 import { Command as Command2 } from "commander";
-import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve2, join as join6 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve3, join as join7 } from "path";
 import readline from "readline";
+
+// src/lib/workspace-tree.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join6, resolve as resolve2 } from "path";
+var SENTINEL_FILENAME = ".oteam-workspace";
+var WORKSPACE_SUBDIRS = [
+  "tickets/triage",
+  "tickets/refined",
+  "tickets/in-progress",
+  "tickets/qa",
+  "tickets/blocked",
+  "projects",
+  "archive",
+  "00-meta"
+];
+var META_README_BODY = `# 00-meta
+
+Workspace metadata. Templates, schema notes, and ad-hoc bookkeeping live
+here. Created by \`oteam init\` \u2014 safe to extend.
+`;
+var SENTINEL_BODY = `${JSON.stringify(
+  { version: 1, createdBy: "@openthink/team" },
+  null,
+  2
+)}
+`;
+function defaultWorkspacePath() {
+  return join6(homedir3(), "openteam");
+}
+var WorkspaceConflictError = class extends Error {
+  path;
+  conflictingPaths;
+  constructor(path, conflictingPaths) {
+    const head = `oteam init: refusing to initialise workspace at ${path} \u2014 directory is non-empty and lacks the ${SENTINEL_FILENAME} marker.`;
+    const list = conflictingPaths.slice(0, 10).map((p) => `  - ${p}`).join("\n");
+    const more = conflictingPaths.length > 10 ? `
+  ...and ${conflictingPaths.length - 10} more` : "";
+    super(`${head}
+Conflicting entries:
+${list}${more}`);
+    this.name = "WorkspaceConflictError";
+    this.path = path;
+    this.conflictingPaths = conflictingPaths;
+  }
+};
+function expandHome(input) {
+  const home = homedir3();
+  if (input === "~") return home;
+  if (input.startsWith("~/")) return join6(home, input.slice(2));
+  return input;
+}
+function bootstrapWorkspace(rawTarget) {
+  const target = resolve2(expandHome(rawTarget));
+  if (existsSync3(join6(target, SENTINEL_FILENAME))) {
+    return { outcome: "already-initialised", path: target };
+  }
+  if (existsSync3(target)) {
+    const visible = readdirSync3(target).filter((n) => !n.startsWith("."));
+    if (visible.length > 0) {
+      throw new WorkspaceConflictError(target, visible);
+    }
+  }
+  mkdirSync4(target, { recursive: true });
+  for (const sub of WORKSPACE_SUBDIRS) {
+    mkdirSync4(join6(target, sub), { recursive: true });
+  }
+  writeFileSync3(join6(target, "00-meta", "README.md"), META_README_BODY);
+  writeFileSync3(join6(target, SENTINEL_FILENAME), SENTINEL_BODY);
+  return { outcome: "created", path: target };
+}
+
+// src/commands/init.ts
 var BLOCK_BEGIN = "<!-- oteam:begin (managed by `oteam init` \u2014 do not edit between markers) -->";
 var BLOCK_END = "<!-- oteam:end -->";
-var AGENTS_BODY = `## oteam \u2014 vault-driven role pipeline for Claude agents
+var AGENTS_BODY = `## oteam \u2014 workspace-driven role pipeline for Claude agents
 
 If the user asks you to **search, find, list, filter, count, or file
-tickets**, or mentions a "vault", an "Obsidian vault", an \`AGT-NNN\` id, a
-project, "ingesting GitHub issues or PRs", or driving tickets through a
-"role pipeline" \u2014 \`oteam\` is the right tool. The vault is a directory of
-markdown files (typically \`~/Documents/<vault>/tickets/<state>/AGT-NNN-*.md\`),
+tickets**, or mentions a "workspace", an "Obsidian vault", an \`AGT-NNN\` id,
+a project, "ingesting GitHub issues or PRs", or driving tickets through a
+"role pipeline" \u2014 \`oteam\` is the right tool. The workspace is a directory
+of markdown files (typically \`~/openteam/tickets/<state>/AGT-NNN-*.md\`),
 but **do not search it with \`find\` or \`grep\` directly.** The CLI knows the
 ticket schema and has structured + free-text filters; filesystem search
 does not, and you will fight false positives from incidental keyword
@@ -1068,13 +1447,13 @@ Other common verbs: \`oteam ticket new "<title>" [--project X]\` to file a
 ticket, \`oteam pull github owner/repo#NN\` to ingest a GitHub issue or PR,
 \`oteam assign <AGT-NNN>\` to drive a ticket through the role pipeline. Run
 \`oteam --help\` or \`oteam <command> --help\` for full details. If you don't
-know whether a vault is configured, \`oteam config vault list\` tells you.
+know whether a workspace is configured, \`oteam config vault list\` tells you.
 `;
 var CLAUDE_BODY = `## oteam
 
 If the user asks to search, find, list, or file tickets, or mentions a
-"vault", "Obsidian vault", an \`AGT-NNN\` id, or a role pipeline, use the
-\`oteam\` CLI \u2014 **do not** \`find\`/\`grep\` the vault directly. Start with
+"workspace", "Obsidian vault", an \`AGT-NNN\` id, or a role pipeline, use the
+\`oteam\` CLI \u2014 **do not** \`find\`/\`grep\` the workspace directly. Start with
 \`oteam list --grep "<term>"\` or \`oteam list --match "<term>"\`. See
 \`AGENTS.md\` next to this file for the short summary and \`oteam --help\` for
 the full surface.
@@ -1089,8 +1468,8 @@ ${BLOCK_END}
 }
 function upsertBlock(filePath, body) {
   const block = renderBlock(body);
-  if (!existsSync3(filePath)) {
-    writeFileSync3(filePath, block, "utf8");
+  if (!existsSync4(filePath)) {
+    writeFileSync4(filePath, block, "utf8");
     return "created";
   }
   const existing = readFileSync4(filePath, "utf8");
@@ -1099,17 +1478,17 @@ function upsertBlock(filePath, body) {
   if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
     const before = existing.slice(0, beginIdx);
     const after = existing.slice(endIdx + BLOCK_END.length);
-    writeFileSync3(filePath, before + block.trimEnd() + after, "utf8");
+    writeFileSync4(filePath, before + block.trimEnd() + after, "utf8");
     return "updated";
   }
   const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-  writeFileSync3(filePath, existing + separator + block, "utf8");
+  writeFileSync4(filePath, existing + separator + block, "utf8");
   return "appended";
 }
-function expandHome(input) {
+function expandHome2(input) {
   const home = process.env.HOME ?? "";
   if (input === "~") return home;
-  if (input.startsWith("~/")) return join6(home, input.slice(2));
+  if (input.startsWith("~/")) return join7(home, input.slice(2));
   return input;
 }
 function prompt(question, fallback) {
@@ -1125,35 +1504,133 @@ function prompt(question, fallback) {
     });
   });
 }
+function promptRaw(question) {
+  return new Promise((resolvePrompt) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolvePrompt(answer.trim());
+    });
+  });
+}
 async function runInit(opts) {
   const home = process.env.HOME ?? "";
-  const defaultDir = home;
-  let targetDir;
-  if (opts.dir) {
-    targetDir = opts.dir;
+  const defaultWorkspace = defaultWorkspacePath();
+  if (opts.dir && opts.workspace && opts.dir !== opts.workspace) {
+    throw new Error(
+      `oteam init: --dir and --workspace disagree (${opts.dir} vs ${opts.workspace}); pass one`
+    );
+  }
+  const workspaceFlag = opts.workspace ?? opts.dir;
+  let workspaceDir;
+  if (workspaceFlag) {
+    workspaceDir = workspaceFlag;
   } else if (opts.yes) {
-    targetDir = defaultDir;
+    workspaceDir = defaultWorkspace;
   } else {
-    targetDir = await prompt(
-      `Where should AGENTS.md / CLAUDE.md be written? (${defaultDir}) `,
-      defaultDir
+    workspaceDir = await prompt(
+      `Where should the oteam workspace live? (${defaultWorkspace}) `,
+      defaultWorkspace
     );
   }
-  targetDir = resolve2(expandHome(targetDir));
-  if (!existsSync3(targetDir)) {
-    process.stderr.write(`oteam init: directory does not exist: ${targetDir}
+  workspaceDir = resolve3(expandHome2(workspaceDir));
+  const bootstrap = bootstrapWorkspace(workspaceDir);
+  const registration = addVault(bootstrap.path);
+  const currentDefault = listVaults().default;
+  const models = seedDefaultModelsIfEmpty();
+  const stamp = await runStampStep(opts);
+  const docsDir = resolve3(expandHome2(opts.docsDir ?? home));
+  if (!existsSync4(docsDir)) {
+    process.stderr.write(`oteam init: docs directory does not exist: ${docsDir}
 `);
     process.exit(1);
   }
-  const agentsPath = join6(targetDir, "AGENTS.md");
-  const claudePath = join6(targetDir, "CLAUDE.md");
+  const agentsPath = join7(docsDir, "AGENTS.md");
+  const claudePath = join7(docsDir, "CLAUDE.md");
   const agents = upsertBlock(agentsPath, AGENTS_BODY);
   const claude = upsertBlock(claudePath, CLAUDE_BODY);
   return {
+    workspace: {
+      path: bootstrap.path,
+      outcome: bootstrap.outcome,
+      registeredAs: registration.name,
+      promotedToDefault: registration.promotedToDefault,
+      currentDefault
+    },
     agents: { path: agentsPath, result: agents },
-    claude: { path: claudePath, result: claude }
+    claude: { path: claudePath, result: claude },
+    stamp,
+    models
   };
 }
+async function runStampStep(opts) {
+  if (opts.skipStamp || opts.yes) {
+    return { action: "skipped" };
+  }
+  const existing = getStampConfig();
+  let hostInput;
+  if (opts.stampHost !== void 0) {
+    hostInput = opts.stampHost.trim();
+  } else {
+    const hint = existing ? ` (current: ${existing.host}; press enter to keep)` : " (leave blank to skip)";
+    hostInput = await promptRaw(
+      `Configure a stamp server for signed-merge integration?
+  Paste host (e.g. ssh://git@host:port)${hint}: `
+    );
+  }
+  let nextHost;
+  if (hostInput.length === 0) {
+    nextHost = existing?.host ?? null;
+  } else {
+    nextHost = hostInput;
+  }
+  if (nextHost === null) {
+    return { action: "unchanged", stamp: null };
+  }
+  let enforce;
+  if (opts.stampEnforce !== void 0) {
+    enforce = opts.stampEnforce;
+  } else {
+    const enforceHint = existing ? ` [${existing.enforce ? "Y/n" : "y/N"}]` : " [y/N]";
+    const enforceAnswer = await promptRaw(
+      `Refuse to operate on repos not registered on this stamp server?${enforceHint}: `
+    );
+    if (enforceAnswer.length === 0) {
+      enforce = existing?.enforce ?? false;
+    } else {
+      enforce = /^(y|yes)$/i.test(enforceAnswer);
+    }
+  }
+  if (existing && existing.host === nextHost && existing.enforce === enforce) {
+    return { action: "unchanged", stamp: existing };
+  }
+  const result = setStamp({ host: nextHost, enforce });
+  return { action: "set", stamp: result };
+}
+function modelsLine(result) {
+  if (result.action === "preserved") {
+    return "\u2139\uFE0F  Models: existing customisation preserved";
+  }
+  const pairs = PHASES.map((phase) => `${phase}=${result.models[phase]}`).join(
+    ", "
+  );
+  return `\u2705 Models: defaults seeded (${pairs})`;
+}
+function stampLine(outcome) {
+  switch (outcome.action) {
+    case "skipped":
+      return null;
+    case "unchanged":
+      if (!outcome.stamp) return null;
+      return `\u2139\uFE0F  Stamp integration: host=${outcome.stamp.host} enforce=${outcome.stamp.enforce ? "on" : "off"} (no changes)`;
+    case "set":
+      if (!outcome.stamp) return "\u2705 Stamp integration: cleared";
+      return `\u2705 Stamp integration: host=${outcome.stamp.host} enforce=${outcome.stamp.enforce ? "on" : "off"}`;
+  }
+}
 function pastTense(action) {
   switch (action) {
     case "created":
@@ -1164,14 +1641,42 @@ function pastTense(action) {
       return "Appended oteam block to";
   }
 }
+function workspaceLine(ws) {
+  if (ws.outcome === "already-initialised") {
+    return `\u2139\uFE0F  Workspace already initialised at ${ws.path} (registered as "${ws.registeredAs}")`;
+  }
+  const trail = ws.promotedToDefault ? "set as default" : ws.currentDefault && ws.currentDefault !== ws.registeredAs ? `current default is "${ws.currentDefault}" \u2014 pass \`oteam config vault default --set ${ws.registeredAs}\` to switch` : "registered";
+  return `\u2705 Created workspace at ${ws.path} (registered as "${ws.registeredAs}"; ${trail})`;
+}
 function buildInitCommand() {
   return new Command2("init").description(
-    "Write oteam guidance to AGENTS.md (full) and CLAUDE.md (pointer) so agents discover oteam at session start"
+    "Bootstrap an oteam workspace and write guidance to AGENTS.md / CLAUDE.md"
   ).option(
     "-d, --dir <path>",
-    "Target directory for AGENTS.md and CLAUDE.md (defaults to $HOME)"
-  ).option("-y, --yes", "Skip prompt, use defaults").action(async (opts) => {
-    const result = await runInit(opts);
+    "Workspace location (default: ~/openteam)"
+  ).option(
+    "-w, --workspace <path>",
+    "Workspace location (alias of --dir)"
+  ).option(
+    "--docs-dir <path>",
+    "Where to write AGENTS.md / CLAUDE.md (default: $HOME)"
+  ).option("-y, --yes", "Skip prompts, use defaults").option(
+    "--skip-stamp",
+    "Skip the stamp host/enforce prompts (leaves any existing config alone)"
+  ).action(async (opts) => {
+    let result;
+    try {
+      result = await runInit(opts);
+    } catch (err) {
+      if (err instanceof WorkspaceConflictError) {
+        process.stderr.write(`${err.message}
+`);
+        process.exit(1);
+      }
+      throw err;
+    }
+    process.stdout.write(`${workspaceLine(result.workspace)}
+`);
     process.stdout.write(
       `\u2705 ${pastTense(result.agents.result)} ${result.agents.path}
 `
@@ -1180,31 +1685,36 @@ function buildInitCommand() {
       `\u2705 ${pastTense(result.claude.result)} ${result.claude.path}
 `
     );
+    process.stdout.write(`${modelsLine(result.models)}
+`);
+    const stampMsg = stampLine(result.stamp);
+    if (stampMsg) process.stdout.write(`${stampMsg}
+`);
   });
 }
 
 // src/commands/project.ts
 import { Command as Command3 } from "commander";
 import { spawnSync } from "child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
 import { basename as basename3 } from "path";
 
 // src/lib/projects.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { join as join8 } from "path";
 function projectsRoot(vaultPath) {
-  return join7(vaultPath, "projects");
+  return join8(vaultPath, "projects");
 }
 function projectDir(vaultPath, id) {
-  return join7(projectsRoot(vaultPath), id);
+  return join8(projectsRoot(vaultPath), id);
 }
 function projectReadmePath(vaultPath, id) {
-  return join7(projectDir(vaultPath, id), "README.md");
+  return join8(projectDir(vaultPath, id), "README.md");
 }
 function readProject(vaultPath, id) {
   const dir = projectDir(vaultPath, id);
   const readme = projectReadmePath(vaultPath, id);
-  if (!existsSync4(readme)) return null;
+  if (!existsSync5(readme)) return null;
   let raw;
   try {
     raw = readFileSync5(readme, "utf8");
@@ -1230,14 +1740,14 @@ function listProjects(vaultPath) {
   const root = projectsRoot(vaultPath);
   let entries = [];
   try {
-    entries = readdirSync3(root);
+    entries = readdirSync4(root);
   } catch {
     return [];
   }
   const projects = [];
   for (const name of entries) {
     if (name.startsWith(".")) continue;
-    const dir = join7(root, name);
+    const dir = join8(root, name);
     let isDir = false;
     try {
       isDir = statSync3(dir).isDirectory();
@@ -1294,7 +1804,7 @@ function bodyAfterFrontmatter(raw) {
 function listSiblings(dir) {
   let entries = [];
   try {
-    entries = readdirSync3(dir);
+    entries = readdirSync4(dir);
   } catch {
     return [];
   }
@@ -1302,7 +1812,7 @@ function listSiblings(dir) {
   for (const name of entries) {
     if (name === "README.md") continue;
     if (name.startsWith(".")) continue;
-    const full = join7(dir, name);
+    const full = join8(dir, name);
     let isFile = false;
     try {
       isFile = statSync3(full).isFile();
@@ -1356,15 +1866,15 @@ function runInit2(id, opts) {
   const vaultPath = resolveVaultPath({ flagValue: opts.vault });
   const dir = projectDir(vaultPath, id);
   const readme = projectReadmePath(vaultPath, id);
-  if (existsSync5(readme)) {
+  if (existsSync6(readme)) {
     process.stderr.write(
       `oteam project init: ${readme} already exists \u2014 refusing to overwrite
 `
     );
     process.exit(1);
   }
-  mkdirSync4(dir, { recursive: true });
-  writeFileSync4(readme, projectFrontmatterTemplate(id), "utf8");
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync5(readme, projectFrontmatterTemplate(id), "utf8");
   process.stdout.write(`\u2705 Created project ${id}
    ${readme}
 `);
@@ -1498,18 +2008,345 @@ function openInEditor(path) {
   }
 }
 
-// src/commands/ticket.ts
+// src/commands/telemetry.ts
 import { Command as Command4 } from "commander";
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
-import { join as join8 } from "path";
+
+// 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 = join8(vault, "tickets", "triage");
-  mkdirSync5(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) {
@@ -1517,8 +2354,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 = join8(triageDir, `${id}-${slug}.md`);
-  if (existsSync6(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`
     );
@@ -1533,14 +2370,14 @@ function runTicketNew(opts) {
     priority: opts.priority ?? "medium",
     labels: opts.labels ?? []
   });
-  writeFileSync5(target, body, "utf8");
+  writeFileSync6(target, body, "utf8");
   return { ticketID: id, path: target };
 }
 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(
@@ -1573,13 +2410,14 @@ function buildTicketCommand() {
 
 // src/role-pipeline/runner.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { writeFileSync as writeFileSync6 } from "fs";
+import { randomUUID } from "crypto";
+import { writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir } from "os";
-import { resolve as resolve3, 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 existsSync7, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync9, readdirSync as readdirSync5 } from "fs";
 var SOCKET_BASENAME = "kitty-claudini";
 var KNOWN_INSTANCES = ["personal", "work"];
 function isMacOS() {
@@ -1611,7 +2449,7 @@ function findKittySocket(kittyPath, preferring) {
   let pidSuffixed = [];
   try {
     const prefix = `${SOCKET_BASENAME}-`;
-    pidSuffixed = readdirSync4("/tmp").filter((n) => n.startsWith(prefix)).map((n) => `/tmp/${n}`).filter((p) => !candidates.includes(p));
+    pidSuffixed = readdirSync5("/tmp").filter((n) => n.startsWith(prefix)).map((n) => `/tmp/${n}`).filter((p) => !candidates.includes(p));
   } catch {
   }
   if (preferring) {
@@ -1622,7 +2460,7 @@ function findKittySocket(kittyPath, preferring) {
     candidates.push(...pidSuffixed);
   }
   for (const path of candidates) {
-    if (!existsSync7(path)) continue;
+    if (!existsSync9(path)) continue;
     const socket = `unix:${path}`;
     const r = spawnSync2(kittyPath, ["@", "--to", socket, "ls"], {
       encoding: "utf8"
@@ -1688,48 +2526,12 @@ function shellEscape(s) {
 }
 
 // src/lib/workspace.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync5, 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";
-
-// src/lib/stamp.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join9 } from "path";
-function stampServerConfigPath() {
-  return join9(homedir3(), ".stamp", "server.yml");
-}
-function readStampServerConfig() {
-  const path = stampServerConfigPath();
-  if (!existsSync8(path)) return null;
-  const raw = readFileSync6(path, "utf8");
-  let host;
-  let port;
-  for (const line of raw.split(/\r?\n/)) {
-    const m = /^(host|port):\s*(.+?)\s*$/.exec(line);
-    if (!m) continue;
-    const value = m[2] ?? "";
-    if (m[1] === "host") host = value;
-    else if (m[1] === "port") {
-      const n = Number.parseInt(value, 10);
-      if (Number.isFinite(n) && n > 0) port = n;
-    }
-  }
-  if (!host || !port) {
-    throw new Error(
-      `${path} is missing required keys (host + port) \u2014 got host=${host ?? "(unset)"} port=${port ?? "(unset)"}`
-    );
-  }
-  return { host, port };
-}
-function buildStampUrl(config, repoBasename) {
-  return `ssh://git@${config.host}:${config.port}/srv/git/${repoBasename}.git`;
-}
+import { basename as basename4, join as join12 } from "path";
 function buildGithubUrl(repoSlug) {
   return `git@github.com:${repoSlug}.git`;
 }
-
-// src/lib/workspace.ts
 var WORKSPACE_ROOT = "/tmp/open-team-issues";
 var TICKET_ID_RE = /^AGT-\d+$/;
 var ORPHAN_DIR_RE = /^agt-\d+$/;
@@ -1747,7 +2549,9 @@ var StampGateError = class extends Error {
       `  Reason: ${args.reason}`,
       `  Fix: provision the repo on the stamp server with`,
       `    stamp provision ${basename4(args.repoSlug)}`,
-      `  Or pass --no-stamp to bypass this gate (not recommended; see README).`
+      `  Or turn enforcement off:`,
+      `    oteam config stamp set --enforce off`,
+      `  Or pass --no-stamp to bypass this gate for a single run.`
     );
     super(lines.join("\n"));
     this.name = "StampGateError";
@@ -1762,34 +2566,31 @@ function prepareAgentWorkspace(opts) {
     );
   }
   const root = opts.rootDir ?? WORKSPACE_ROOT;
-  mkdirSync6(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 });
-  mkdirSync6(ticketDir, { recursive: true });
+  mkdirSync8(ticketDir, { recursive: true });
   const repoBasename = basename4(opts.repoSlug);
   const cloneRunner = opts.cloneRunner ?? defaultCloneRunner;
-  if (opts.noStamp) {
+  if (opts.mode === "github") {
     const url = buildGithubUrl(opts.repoSlug);
     const r2 = cloneRunner(url, repoDir);
     if (r2.status !== 0) {
       throw new Error(
-        `oteam assign: --no-stamp fallback clone failed (git clone ${url}):
+        `oteam assign: github clone failed (git clone ${url}):
 ${r2.stderr.trim() || "(no stderr)"}`
       );
     }
     return { path: repoDir, originUrl: url, source: "github" };
   }
-  const stampConfig = readStampServerConfig();
-  if (!stampConfig) {
-    throw new StampGateError({
-      repoSlug: opts.repoSlug,
-      stampUrl: null,
-      reason: `${stampServerConfigPath()} not found \u2014 no stamp server is configured`
-    });
+  if (!opts.stampHost || opts.stampHost.trim().length === 0) {
+    throw new Error(
+      "prepareAgentWorkspace: mode='stamp' requires opts.stampHost (run 'oteam config stamp set --host <url>')"
+    );
   }
-  const stampUrl = buildStampUrl(stampConfig, repoBasename);
+  const stampUrl = buildStampCloneUrl(opts.stampHost, repoBasename);
   const r = cloneRunner(stampUrl, repoDir);
   if (r.status !== 0) {
     throw new StampGateError({
@@ -1801,6 +2602,9 @@ ${r2.stderr.trim() || "(no stderr)"}`
   }
   return { path: repoDir, originUrl: stampUrl, source: "stamp" };
 }
+function buildStampCloneUrl(host, repoBasename) {
+  return `${host}/srv/git/${repoBasename}.git`;
+}
 function stampGateReason(r) {
   const stderr = r.stderr.trim();
   if (!stderr) return `git clone exited ${r.status}`;
@@ -1818,18 +2622,18 @@ var defaultCloneRunner = (url, dest) => {
   };
 };
 function gcOrphanWorkspaces(root, activeTicketIds) {
-  if (!existsSync9(root)) return [];
+  if (!existsSync10(root)) return [];
   const removed = [];
   let entries;
   try {
-    entries = readdirSync5(root);
+    entries = readdirSync6(root);
   } catch {
     return [];
   }
   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);
@@ -1840,22 +2644,22 @@ function gcOrphanWorkspaces(root, activeTicketIds) {
 }
 
 // src/role-pipeline/install-slash-command.ts
-import { copyFileSync, existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync6, readFileSync as readFileSync7, 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 = readFileSync7(BUNDLED_PROMPT);
+  if (!existsSync11(BUNDLED_PROMPT)) return;
+  const bundled = readFileSync8(BUNDLED_PROMPT);
   const targets = resolveTargetDirs();
   for (const dir of targets) {
     try {
-      mkdirSync7(dir, { recursive: true });
-      const target = join11(dir, "assign-ticket.md");
-      if (existsSync10(target)) {
-        const current = readFileSync7(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);
@@ -1864,23 +2668,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 readdirSync6(home)) {
+    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 {
   }
@@ -1888,6 +2692,18 @@ function resolveTargetDirs() {
 }
 
 // src/role-pipeline/runner.ts
+function resolveWorkspaceMode(config, noStamp) {
+  if (noStamp) return "github";
+  if (config.stamp?.enforce) {
+    if (!config.stamp.host || config.stamp.host.length === 0) {
+      throw new Error(
+        "oteam assign: stamp.enforce is on but stamp.host is empty \u2014 run 'oteam config stamp set --host <url>' or 'oteam config stamp set --enforce off'"
+      );
+    }
+    return "stamp";
+  }
+  return "github";
+}
 async function assignTicket(opts) {
   const config = readConfig();
   let resolvedVault = resolveVault({ flagValue: opts.vault, config });
@@ -1895,7 +2711,7 @@ async function assignTicket(opts) {
   if (isAgtId(opts.ticketPath)) {
     ticketPath = findTicketFileByID(resolvedVault.path, opts.ticketPath);
   } else {
-    ticketPath = resolve3(opts.ticketPath);
+    ticketPath = resolve4(opts.ticketPath);
     if (!opts.vault) {
       const detected = findVaultRootForPath(ticketPath, config);
       if (detected) resolvedVault = detected;
@@ -1916,11 +2732,13 @@ async function assignTicket(opts) {
   }
   let workspace = null;
   if (ticket.repo) {
+    const mode = resolveWorkspaceMode(config, opts.noStamp ?? false);
     try {
       workspace = prepareAgentWorkspace({
         ticketId: ticket.id,
         repoSlug: ticket.repo,
-        noStamp: opts.noStamp ?? false,
+        mode,
+        stampHost: mode === "stamp" ? config.stamp?.host : void 0,
         activeTicketIds: collectActiveTicketIds(resolvedVault.path)
       });
     } catch (err) {
@@ -1931,7 +2749,7 @@ async function assignTicket(opts) {
       }
       throw err;
     }
-    if (opts.noStamp) {
+    if (opts.noStamp && config.stamp?.enforce) {
       process.stderr.write(
         `oteam assign: --no-stamp set; cloned from ${workspace.originUrl}. The stamp gate is bypassed \u2014 verify any push manually.
 `
@@ -1939,9 +2757,25 @@ async function assignTicket(opts) {
     }
   }
   const projectContext = loadProjectContext(resolvedVault.path, ticket.project);
+  const model = resolveRoleModel(ticket.state, config.models);
+  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);
+    runInline(
+      claudePath,
+      ticketPath,
+      resolvedVault.path,
+      projectContext,
+      workspace,
+      model,
+      telemetry
+    );
     return;
   }
   const monitored = opts.monitoredOrgs ?? readMonitoredOrgsFromEnv();
@@ -1952,7 +2786,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);
+    runInline(
+      claudePath,
+      ticketPath,
+      resolvedVault.path,
+      projectContext,
+      workspace,
+      model,
+      telemetry
+    );
     return;
   }
   const cwd = workspace?.path ?? dirname2(ticketPath);
@@ -1967,7 +2809,17 @@ async function assignTicket(opts) {
   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 ${ROLE_PIPELINE_MODEL}${projectFlag} '${escapedPrompt}'`;
+  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,
@@ -1981,16 +2833,32 @@ async function assignTicket(opts) {
     );
   }
 }
-function runInline(claudePath, ticketPath, vaultPath, projectContext, workspace) {
+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, projectContext, workspace, model, telemetry) {
   const args = [
     "--dangerously-skip-permissions",
     "--model",
-    ROLE_PIPELINE_MODEL
+    model
   ];
+  if (telemetry) {
+    args.push("--session-id", telemetry.sessionId);
+  }
   if (projectContext) {
     args.push("--append-system-prompt", projectContext.content);
   }
   args.push(`/assign-ticket ${ticketPath}`);
+  const cwd = workspace?.path ?? process.cwd();
   const r = spawnSync4(
     claudePath,
     args,
@@ -2000,6 +2868,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) {
@@ -2024,8 +2903,8 @@ function loadProjectContext(vaultPath, projectId) {
   }
   const content = formatProjectContextForPrompt(project);
   const safeId = projectId.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const tmpFile = join12(tmpdir(), `oteam-project-${safeId}.md`);
-  writeFileSync6(tmpFile, content, "utf8");
+  const tmpFile = join14(tmpdir(), `oteam-project-${safeId}.md`);
+  writeFileSync7(tmpFile, content, "utf8");
   return { tmpFile, content };
 }
 function findToolOnPath(name) {
@@ -2041,7 +2920,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");
@@ -2074,7 +2953,7 @@ program.command("assign <ticket-or-id>").description(
   "Run the role pipeline in the current terminal instead of spawning kitty"
 ).option("--vault <name-or-path>", "Use a specific registered vault").option(
   "--no-stamp",
-  "Skip the stamp-server gate; clone the agent worktree from GitHub instead. Not recommended \u2014 bypasses the safeguard against agents pushing direct to GitHub. Use only when the repo is intentionally not stamp-governed."
+  "Force a github clone for this run, overriding stamp.enforce in oteam config. The durable knob is 'oteam config stamp set --enforce off'."
 ).action(
   async (ticketPath, opts) => {
     await assignTicket({
@@ -2120,6 +2999,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}