@openthink/team 0.0.1 → 0.0.2

package/dist/index.js

@@ -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,20 @@ 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;
+  }
+  const body = JSON.stringify(onDisk, null, 2) + "\n";
   writeFileSync(configPath(), body);
 }
+function emptyConfig() {
+  return { vaults: {}, default: null, stamp: null, models: {} };
+}
 function addVault(rawPath, options = {}) {
   const path = absolutise(rawPath);
   const config = readConfig();
@@ -533,7 +575,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 +586,131 @@ 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)
+  };
+}
+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 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;
@@ -1033,24 +1201,188 @@ function buildConfigCommand() {
     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");
+  });
   config.addCommand(vault);
+  config.addCommand(stamp);
+  config.addCommand(models);
   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 +1400,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 +1421,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 +1431,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 +1457,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 +1594,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 +1638,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 +1693,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 +1757,7 @@ function bodyAfterFrontmatter(raw) {
 function listSiblings(dir) {
   let entries = [];
   try {
-    entries = readdirSync3(dir);
+    entries = readdirSync4(dir);
   } catch {
     return [];
   }
@@ -1302,7 +1765,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 +1819,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}
 `);
@@ -1500,16 +1963,16 @@ function openInEditor(path) {
 
 // src/commands/ticket.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";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join9 } 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 = join9(vault, "tickets", "triage");
+  mkdirSync6(triageDir, { recursive: true });
   const id = nextTicketID(vault);
   const slug = slugify(title);
   if (slug.length === 0) {
@@ -1517,8 +1980,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 = join9(triageDir, `${id}-${slug}.md`);
+  if (existsSync7(target)) {
     throw new Error(
       `oteam ticket new: target already exists at ${target} \u2014 ID scan collision`
     );
@@ -1533,7 +1996,7 @@ 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 = []) {
@@ -1573,13 +2036,13 @@ function buildTicketCommand() {
 
 // src/role-pipeline/runner.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { writeFileSync as writeFileSync6 } from "fs";
+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 join12 } 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 existsSync8, readdirSync as readdirSync5 } from "fs";
 var SOCKET_BASENAME = "kitty-claudini";
 var KNOWN_INSTANCES = ["personal", "work"];
 function isMacOS() {
@@ -1611,7 +2074,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 +2085,7 @@ function findKittySocket(kittyPath, preferring) {
     candidates.push(...pidSuffixed);
   }
   for (const path of candidates) {
-    if (!existsSync7(path)) continue;
+    if (!existsSync8(path)) continue;
     const socket = `unix:${path}`;
     const r = spawnSync2(kittyPath, ["@", "--to", socket, "ls"], {
       encoding: "utf8"
@@ -1688,48 +2151,12 @@ function shellEscape(s) {
 }
 
 // src/lib/workspace.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync5, rmSync } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, 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`;
-}
 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 +2174,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 +2191,31 @@ function prepareAgentWorkspace(opts) {
     );
   }
   const root = opts.rootDir ?? WORKSPACE_ROOT;
-  mkdirSync6(root, { recursive: true });
+  mkdirSync7(root, { recursive: true });
   if (opts.activeTicketIds) gcOrphanWorkspaces(root, opts.activeTicketIds);
   const ticketDir = join10(root, opts.ticketId.toLowerCase());
   const repoDir = join10(ticketDir, "repo");
   rmSync(ticketDir, { recursive: true, force: true });
-  mkdirSync6(ticketDir, { recursive: true });
+  mkdirSync7(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 +2227,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}`;
@@ -1822,7 +2251,7 @@ function gcOrphanWorkspaces(root, activeTicketIds) {
   const removed = [];
   let entries;
   try {
-    entries = readdirSync5(root);
+    entries = readdirSync6(root);
   } catch {
     return [];
   }
@@ -1840,7 +2269,7 @@ 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 { 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 { fileURLToPath } from "url";
@@ -1848,14 +2277,14 @@ var moduleDir = dirname(fileURLToPath(import.meta.url));
 var BUNDLED_PROMPT = join11(moduleDir, "assign-ticket.md");
 function installRolePipelineSlashCommand() {
   if (!existsSync10(BUNDLED_PROMPT)) return;
-  const bundled = readFileSync7(BUNDLED_PROMPT);
+  const bundled = readFileSync6(BUNDLED_PROMPT);
   const targets = resolveTargetDirs();
   for (const dir of targets) {
     try {
-      mkdirSync7(dir, { recursive: true });
+      mkdirSync8(dir, { recursive: true });
       const target = join11(dir, "assign-ticket.md");
       if (existsSync10(target)) {
-        const current = readFileSync7(target);
+        const current = readFileSync6(target);
         if (current.equals(bundled)) continue;
       }
       copyFileSync(BUNDLED_PROMPT, target);
@@ -1872,7 +2301,7 @@ function resolveTargetDirs() {
     dirs.add(join11(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);
       let isDir = false;
@@ -1888,6 +2317,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 +2336,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 +2357,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 +2374,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 +2382,10 @@ async function assignTicket(opts) {
     }
   }
   const projectContext = loadProjectContext(resolvedVault.path, ticket.project);
+  const model = resolveRoleModel(ticket.state, config.models);
   const kittyPath = !opts.workInline && isMacOS() ? findKittyBinary() : null;
   if (!kittyPath) {
-    runInline(claudePath, ticketPath, resolvedVault.path, projectContext, workspace);
+    runInline(claudePath, ticketPath, resolvedVault.path, projectContext, workspace, model);
     return;
   }
   const monitored = opts.monitoredOrgs ?? readMonitoredOrgsFromEnv();
@@ -1952,7 +2396,7 @@ 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);
     return;
   }
   const cwd = workspace?.path ?? dirname2(ticketPath);
@@ -1967,7 +2411,7 @@ 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 shellCmd = `${envPrefix}exec '${escapedClaude}' --dangerously-skip-permissions --model ${shellEscape(model)}${projectFlag} '${escapedPrompt}'`;
   const result = kittyLaunch({
     socket,
     title,
@@ -1981,11 +2425,11 @@ async function assignTicket(opts) {
     );
   }
 }
-function runInline(claudePath, ticketPath, vaultPath, projectContext, workspace) {
+function runInline(claudePath, ticketPath, vaultPath, projectContext, workspace, model) {
   const args = [
     "--dangerously-skip-permissions",
     "--model",
-    ROLE_PIPELINE_MODEL
+    model
   ];
   if (projectContext) {
     args.push("--append-system-prompt", projectContext.content);
@@ -2025,7 +2469,7 @@ 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");
+  writeFileSync7(tmpFile, content, "utf8");
   return { tmpFile, content };
 }
 function findToolOnPath(name) {
@@ -2074,7 +2518,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({