@codex-modules/teams 0.1.1

package/dist/doctor.js

@@ -0,0 +1,128 @@
+import { spawnSync } from "node:child_process";
+import { accessSync, constants as fsConstants, existsSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+import { findCodexBinary, listInstalledTeams, parseModelCatalog, resolveAgentsRoot, resolveCodexHome } from "./agents.js";
+import { resolveStateRoot } from "./state.js";
+export function doctor(opts = {}) {
+    const env = opts.env ?? process.env;
+    const codexHome = resolveCodexHome(env, opts.codexHome);
+    const bin = findCodexBinary(env);
+    const version = bin ? getCodexVersion(bin) : null;
+    let features = [];
+    let featuresError;
+    if (bin) {
+        try {
+            features = listFeatures(bin, { ...process.env, ...env, CODEX_HOME: codexHome });
+        }
+        catch (error) {
+            featuresError = error instanceof Error ? error.message : String(error);
+        }
+    }
+    const multiAgent = featureState(features, "multi_agent");
+    const fanout = featureState(features, "enable_fanout");
+    const multiAgentV2 = featureState(features, "multi_agent_v2");
+    const agentsRoot = resolveAgentsRoot("user", { codexHome, env });
+    const projectAgentsRoot = resolveAgentsRoot("project", { cwd: opts.cwd, env });
+    const stateRoot = resolveStateRoot({ cwd: opts.cwd, stateDir: opts.stateDir, env });
+    return {
+        codexBinary: bin,
+        version,
+        features,
+        featuresError,
+        multiAgent,
+        fanout,
+        multiAgentV2,
+        models: bin ? debugModels(bin, { ...process.env, ...env, CODEX_HOME: codexHome }) : { ok: false, values: [], error: "codex binary not found" },
+        agentsDirWritable: canWriteDir(agentsRoot),
+        stateDirWritable: canWriteDir(stateRoot),
+        userInstalledTeams: existsSync(agentsRoot) ? listInstalledTeams(agentsRoot) : [],
+        projectInstalledTeams: existsSync(projectAgentsRoot) ? listInstalledTeams(projectAgentsRoot) : [],
+    };
+}
+export function doctorIsHealthy(report) {
+    return Boolean(report.codexBinary && report.multiAgent.present && report.multiAgent.stage === "stable" && report.multiAgent.enabled);
+}
+export function formatDoctor(report) {
+    const lines = [
+        `codex binary: ${report.codexBinary ?? "not found"}`,
+        `version: ${report.version ?? "unknown"}`,
+        `multi_agent: ${formatFeature(report.multiAgent)}`,
+        `enable_fanout: ${formatFeature(report.fanout)} (under development - report only)`,
+        `multi_agent_v2: ${formatFeature(report.multiAgentV2)} (under development - report only)`,
+        report.featuresError ? `features error: ${report.featuresError}` : null,
+        report.models.ok ? `models: ${report.models.values.length}` : `models: unavailable (${report.models.error ?? "unknown error"})`,
+        `agents dir writable: ${report.agentsDirWritable}`,
+        `state dir writable: ${report.stateDirWritable}`,
+        `user installed teams: ${report.userInstalledTeams.length ? report.userInstalledTeams.join(", ") : "none"}`,
+        `project installed teams: ${report.projectInstalledTeams.length ? report.projectInstalledTeams.join(", ") : "none"}`,
+    ].filter((line) => Boolean(line));
+    return `${lines.join("\n")}\n`;
+}
+function getCodexVersion(bin) {
+    const result = spawnSync(bin, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 5000 });
+    if (result.status !== 0 || result.error)
+        return null;
+    return `${result.stdout}${result.stderr}`.trim() || null;
+}
+function listFeatures(bin, env) {
+    const result = spawnSync(bin, ["features", "list"], { env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 5000 });
+    if (result.status !== 0 || result.error) {
+        const reason = result.error ? result.error.message : result.stderr.trim();
+        throw new Error(`codex features list failed${reason ? `: ${reason}` : ""}`);
+    }
+    return result.stdout
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean)
+        .flatMap(line => {
+        const match = line.match(/^(\S+)\s+(.+)\s+(true|false)$/i);
+        if (!match)
+            return [];
+        return [{ name: match[1], stage: match[2].trim(), enabled: match[3].toLowerCase() === "true" }];
+    });
+}
+function debugModels(bin, env) {
+    const result = spawnSync(bin, ["debug", "models"], { env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10_000 });
+    if (result.status !== 0 || result.error) {
+        const reason = result.error ? result.error.message : result.stderr.trim();
+        return { ok: false, values: [], error: reason || "codex debug models failed" };
+    }
+    try {
+        return { ok: true, values: parseModelCatalog(result.stdout) };
+    }
+    catch (error) {
+        return { ok: false, values: [], error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function featureState(features, name) {
+    const found = features.find(feature => feature.name === name);
+    return found ? { present: true, stage: found.stage, enabled: found.enabled } : { present: false };
+}
+function formatFeature(feature) {
+    if (!feature || !feature.present)
+        return "not reported";
+    return `${feature.stage ?? "unknown"} enabled=${feature.enabled ?? false}`;
+}
+function canWriteDir(dir) {
+    try {
+        const target = nearestExistingPath(dir);
+        if (!statSync(target).isDirectory())
+            return false;
+        accessSync(target, fsConstants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function nearestExistingPath(path) {
+    let current = path;
+    for (;;) {
+        if (existsSync(current))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return current;
+        current = parent;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export type { BoundMember, DoctorReport, FinishStatus, InstallScope, JournalEntry, JournalKind, MemberDef, MemberLens, SandboxMode, StateFile, TaskRecord, TaskStatus, TasksFile, TeamDefaults, TeamDef, TeamStatus, } from "./types.js";
+export type { InstallOptions, InstallResult, UninstallResult } from "./agents.js";
+export type { DoctorOptions } from "./doctor.js";
+export type { DryRunPlan, RunOptions, RunResult } from "./runner.js";
+export type { StateOptions } from "./state.js";
+export { installTeam, listInstalledTeams, renderAgentToml, resolveAgentsRoot, uninstallTeam } from "./agents.js";
+export { doctor, doctorIsHealthy, formatDoctor } from "./doctor.js";
+export { assembleLeaderPrompt } from "./prompt.js";
+export { buildRunPlan, runTeam } from "./runner.js";
+export { addNote, addTask, bindMember, claimTask, completeTask, finishState, initState, listNotes, listTasks, showState } from "./state.js";
+export { parseTeamJson, scaffoldTeam, validateTeamDef, writePreset } from "./team.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export { installTeam, listInstalledTeams, renderAgentToml, resolveAgentsRoot, uninstallTeam } from "./agents.js";
+export { doctor, doctorIsHealthy, formatDoctor } from "./doctor.js";
+export { assembleLeaderPrompt } from "./prompt.js";
+export { buildRunPlan, runTeam } from "./runner.js";
+export { addNote, addTask, bindMember, claimTask, completeTask, finishState, initState, listNotes, listTasks, showState } from "./state.js";
+export { parseTeamJson, scaffoldTeam, validateTeamDef, writePreset } from "./team.js";

package/dist/lock.d.ts

@@ -0,0 +1,14 @@
+export type LockHandle = {
+    path: string;
+    release(): void;
+};
+export declare function acquireMkdirLock(path: string, opts?: {
+    ttlMs?: number;
+    waitMs?: number;
+    purpose?: string;
+}): LockHandle;
+export declare function withLock<T>(path: string, opts: {
+    ttlMs?: number;
+    waitMs?: number;
+    purpose?: string;
+}, fn: () => T): T;

package/dist/lock.js

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { hostname } from "node:os";
+import { join } from "node:path";
+export function acquireMkdirLock(path, opts = {}) {
+    const ttlMs = opts.ttlMs ?? 30_000;
+    const waitMs = opts.waitMs ?? 10_000;
+    const deadline = Date.now() + waitMs;
+    for (;;) {
+        try {
+            mkdirSync(path, { recursive: false });
+            writeFileSync(join(path, "owner.json"), `${JSON.stringify({
+                pid: process.pid,
+                host: hostname(),
+                acquiredAt: new Date().toISOString(),
+                expiresAt: new Date(Date.now() + ttlMs).toISOString(),
+                purpose: opts.purpose ?? "teams",
+            }, null, 2)}\n`);
+            return {
+                path,
+                release() {
+                    rmSync(path, { recursive: true, force: true });
+                },
+            };
+        }
+        catch {
+            if (isStale(path)) {
+                rmSync(path, { recursive: true, force: true });
+                continue;
+            }
+            if (Date.now() > deadline)
+                throw new Error(`Timed out acquiring lock: ${path}`);
+            sleep(25);
+        }
+    }
+}
+export function withLock(path, opts, fn) {
+    const lock = acquireMkdirLock(path, opts);
+    try {
+        return fn();
+    }
+    finally {
+        lock.release();
+    }
+}
+function isStale(path) {
+    if (!existsSync(path))
+        return false;
+    try {
+        const owner = JSON.parse(readFileSync(join(path, "owner.json"), "utf8"));
+        return owner.expiresAt ? Date.parse(owner.expiresAt) <= Date.now() : false;
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}

package/dist/main.d.ts

@@ -0,0 +1 @@
+export declare function main(args: string[]): Promise<void>;

package/dist/main.js

@@ -0,0 +1,378 @@
+import { installTeam, uninstallTeam } from "./agents.js";
+import { doctor, doctorIsHealthy, formatDoctor } from "./doctor.js";
+import { assembleLeaderPrompt } from "./prompt.js";
+import { runTeam } from "./runner.js";
+import { installSkill, uninstallSkill } from "./skill.js";
+import { addNote, addTask, bindMember, claimTask, completeTask, finishState, initState, listNotes, listTasks, showState, } from "./state.js";
+import { collectTeamErrors, parseTeamJson, writePreset } from "./team.js";
+export async function main(args) {
+    try {
+        await run(args);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+async function run(args) {
+    const [command, ...rest] = args;
+    if (!command || command === "--help" || command === "-h") {
+        printHelp();
+        return;
+    }
+    if (command === "init") {
+        const parsed = parseArgs(rest);
+        const preset = flag(parsed, "preset") ?? "review-panel";
+        if (preset !== "review-panel" && preset !== "swarm" && preset !== "pipeline")
+            throw new Error("--preset must be review-panel, swarm, or pipeline");
+        writePreset(flag(parsed, "out") ?? "team.json", preset);
+        console.log("OK init");
+        return;
+    }
+    if (command === "validate") {
+        const parsed = parseArgs(rest);
+        const file = parsed.positional[0];
+        if (!file)
+            throw new Error("usage: codex-teams validate <team.json>");
+        const raw = JSON.parse(await import("node:fs").then(fs => fs.readFileSync(file, "utf8")));
+        const errors = collectTeamErrors(raw);
+        if (errors.length > 0)
+            throw new Error(`${file} is invalid:\n- ${errors.join("\n- ")}`);
+        console.log("OK validate");
+        return;
+    }
+    if (command === "doctor") {
+        const parsed = parseArgs(rest);
+        const report = doctor({ codexHome: flag(parsed, "codex-home"), stateDir: flag(parsed, "state-dir") });
+        if (boolFlag(parsed, "json"))
+            console.log(JSON.stringify(report, null, 2));
+        else
+            process.stdout.write(formatDoctor(report));
+        if (!doctorIsHealthy(report))
+            process.exitCode = 1;
+        return;
+    }
+    if (command === "install") {
+        const parsed = parseArgs(rest);
+        const file = parsed.positional[0];
+        if (!file)
+            throw new Error("usage: codex-teams install <team.json>");
+        const result = installTeam(file, {
+            codexHome: flag(parsed, "codex-home"),
+            scope: scopeFlag(parsed),
+            force: boolFlag(parsed, "force"),
+            skipModelCheck: boolFlag(parsed, "skip-model-check"),
+        });
+        for (const warning of result.warnings)
+            console.error(`WARN ${warning}`);
+        console.log(`OK install ${result.team} ${result.files.length} file(s)`);
+        return;
+    }
+    if (command === "uninstall") {
+        const parsed = parseArgs(rest);
+        const team = parsed.positional[0];
+        if (!team)
+            throw new Error("usage: codex-teams uninstall <team-name>");
+        const result = uninstallTeam(team, { codexHome: flag(parsed, "codex-home"), scope: scopeFlag(parsed) });
+        for (const warning of result.warnings)
+            console.error(`WARN ${warning}`);
+        console.log(`OK uninstall ${result.team} removed=${result.removed.length} restored=${result.restored.length}`);
+        return;
+    }
+    if (command === "leader-prompt") {
+        const parsed = parseArgs(rest);
+        const file = parsed.positional[0];
+        const goal = requiredFlag(parsed, "goal");
+        if (!file)
+            throw new Error("usage: codex-teams leader-prompt <team.json> --goal <text>");
+        process.stdout.write(assembleLeaderPrompt(parseTeamJson(file), goal));
+        return;
+    }
+    if (command === "skill") {
+        const [subcommand, ...skillRest] = rest;
+        const parsed = parseArgs(skillRest);
+        if (subcommand === "install") {
+            const result = installSkill({ codexHome: flag(parsed, "codex-home"), force: boolFlag(parsed, "force") });
+            console.log(`OK skill install ${result.file}`);
+            return;
+        }
+        if (subcommand === "uninstall") {
+            const result = uninstallSkill({ codexHome: flag(parsed, "codex-home") });
+            console.log(`OK skill uninstall removed=${result.removed.length} restored=${result.restored.length}`);
+            return;
+        }
+        throw new Error("usage: codex-teams skill install|uninstall");
+    }
+    if (command === "run") {
+        const parsed = parseArgs(rest);
+        const file = parsed.positional[0];
+        if (!file)
+            throw new Error("usage: codex-teams run <team.json> --goal <text>");
+        const result = await runTeam(file, {
+            goal: requiredFlag(parsed, "goal"),
+            codexHome: flag(parsed, "codex-home"),
+            stateDir: flag(parsed, "state-dir"),
+            sandbox: sandboxFlag(parsed),
+            timeoutSec: numberFlag(parsed, "timeout-sec"),
+            stallSec: numberFlag(parsed, "stall-sec"),
+            execute: boolFlag(parsed, "execute"),
+            allowCodex: boolFlag(parsed, "allow-codex"),
+        });
+        if (result.mode === "dry-run") {
+            console.log("DRY-RUN codex argv:");
+            console.log(result.argv.map(shellQuote).join(" "));
+            console.log("DRY-RUN leader prompt:");
+            process.stdout.write(result.prompt);
+        }
+        else {
+            console.log(`OK run ${result.status} exit=${result.exitCode ?? "null"} runDir=${result.runDir}`);
+        }
+        return;
+    }
+    if (command === "state") {
+        handleState(rest);
+        return;
+    }
+    if (command === "member") {
+        handleMember(rest);
+        return;
+    }
+    if (command === "task") {
+        handleTask(rest);
+        return;
+    }
+    if (command === "note") {
+        handleNote(rest);
+        return;
+    }
+    throw new Error(`unknown command: ${command}`);
+}
+function handleState(args) {
+    const [subcommand, ...rest] = args;
+    const parsed = parseArgs(rest);
+    const team = parsed.positional[0];
+    if (!team)
+        throw new Error("usage: codex-teams state init|show|finish <team>");
+    const opts = { stateDir: flag(parsed, "state-dir") };
+    if (subcommand === "init") {
+        const result = initState(team, requiredFlag(parsed, "goal"), { ...opts, noGitignore: boolFlag(parsed, "no-gitignore") });
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (subcommand === "show") {
+        const result = showState(team, opts);
+        if (boolFlag(parsed, "json"))
+            console.log(JSON.stringify(result, null, 2));
+        else
+            console.log(`team=${result.team} status=${result.status} goal=${result.goal}`);
+        return;
+    }
+    if (subcommand === "finish") {
+        const status = requiredFlag(parsed, "status");
+        if (status !== "ok" && status !== "partial")
+            throw new Error("--status must be ok or partial");
+        console.log(JSON.stringify(finishState(team, status, opts), null, 2));
+        return;
+    }
+    throw new Error("usage: codex-teams state init|show|finish <team>");
+}
+function handleMember(args) {
+    const [subcommand, ...rest] = args;
+    const parsed = parseArgs(rest);
+    if (subcommand !== "bind")
+        throw new Error("usage: codex-teams member bind <team> <member> --agent-id <id>");
+    const [team, member] = parsed.positional;
+    if (!team || !member)
+        throw new Error("usage: codex-teams member bind <team> <member> --agent-id <id>");
+    console.log(JSON.stringify(bindMember(team, member, requiredFlag(parsed, "agent-id"), { stateDir: flag(parsed, "state-dir"), nickname: flag(parsed, "nickname") }), null, 2));
+}
+function handleTask(args) {
+    const [subcommand, ...rest] = args;
+    const parsed = parseArgs(rest);
+    const [team, taskId] = parsed.positional;
+    if (!team)
+        throw new Error("usage: codex-teams task add|claim|complete|fail|list <team>");
+    const opts = { stateDir: flag(parsed, "state-dir") };
+    if (subcommand === "add") {
+        const task = addTask(team, { title: requiredFlag(parsed, "title"), detail: flag(parsed, "detail"), dependsOn: splitCsv(flag(parsed, "depends-on")) }, opts);
+        console.log(JSON.stringify(task, null, 2));
+        return;
+    }
+    if (subcommand === "claim") {
+        if (!taskId)
+            throw new Error("usage: codex-teams task claim <team> <task-id> --actor <name>");
+        console.log(JSON.stringify(claimTask(team, taskId, { actor: requiredFlag(parsed, "actor"), leaseSec: numberFlag(parsed, "lease-sec") }, opts), null, 2));
+        return;
+    }
+    if (subcommand === "complete" || subcommand === "fail") {
+        if (!taskId)
+            throw new Error(`usage: codex-teams task ${subcommand} <team> <task-id> --actor <name>`);
+        console.log(JSON.stringify(completeTask(team, taskId, { actor: requiredFlag(parsed, "actor"), result: flag(parsed, "result"), failed: subcommand === "fail" }, opts), null, 2));
+        return;
+    }
+    if (subcommand === "list") {
+        const tasks = listTasks(team, { ...opts, reclaim: boolFlag(parsed, "reclaim") });
+        if (boolFlag(parsed, "json"))
+            console.log(JSON.stringify(tasks, null, 2));
+        else
+            for (const task of tasks.tasks)
+                console.log(`${task.id}\t${task.status}\t${task.title}`);
+        return;
+    }
+    throw new Error("usage: codex-teams task add|claim|complete|fail|list <team>");
+}
+function handleNote(args) {
+    const [subcommand, ...rest] = args;
+    const parsed = parseArgs(rest);
+    const team = parsed.positional[0];
+    if (!team)
+        throw new Error("usage: codex-teams note add|list <team>");
+    const opts = { stateDir: flag(parsed, "state-dir") };
+    if (subcommand === "add") {
+        console.log(JSON.stringify(addNote(team, { actor: requiredFlag(parsed, "actor"), text: requiredFlag(parsed, "text"), kind: kindFlag(parsed) }, opts), null, 2));
+        return;
+    }
+    if (subcommand === "list") {
+        const notes = listNotes(team, opts);
+        if (boolFlag(parsed, "json"))
+            console.log(JSON.stringify(notes, null, 2));
+        else
+            for (const note of notes)
+                console.log(`${note.ts}\t${note.actor}\t${note.kind}\t${note.text}`);
+        return;
+    }
+    throw new Error("usage: codex-teams note add|list <team>");
+}
+function parseArgs(args) {
+    const positional = [];
+    const flags = new Map();
+    const valueFlags = new Set([
+        "actor",
+        "agent-id",
+        "codex-home",
+        "depends-on",
+        "detail",
+        "goal",
+        "kind",
+        "lease-sec",
+        "model",
+        "nickname",
+        "out",
+        "preset",
+        "result",
+        "sandbox",
+        "scope",
+        "stall-sec",
+        "state-dir",
+        "status",
+        "text",
+        "timeout-sec",
+        "title",
+    ]);
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--") {
+            positional.push(...args.slice(i + 1));
+            break;
+        }
+        if (arg.startsWith("--")) {
+            const eq = arg.indexOf("=");
+            if (eq !== -1) {
+                flags.set(arg.slice(2, eq), arg.slice(eq + 1));
+                continue;
+            }
+            const name = arg.slice(2);
+            const next = args[i + 1];
+            if (valueFlags.has(name)) {
+                if (next === undefined)
+                    throw new Error(`--${name} requires a value`);
+                flags.set(name, next);
+                i++;
+            }
+            else {
+                flags.set(name, true);
+            }
+            continue;
+        }
+        if (arg === "-s") {
+            const next = args[++i];
+            if (!next)
+                throw new Error("-s requires a value");
+            flags.set("sandbox", next);
+            continue;
+        }
+        positional.push(arg);
+    }
+    return { positional, flags };
+}
+function flag(parsed, name) {
+    const value = parsed.flags.get(name);
+    if (value === undefined || value === true)
+        return undefined;
+    return value;
+}
+function requiredFlag(parsed, name) {
+    const value = flag(parsed, name);
+    if (!value)
+        throw new Error(`--${name} is required`);
+    return value;
+}
+function boolFlag(parsed, name) {
+    return parsed.flags.get(name) === true || parsed.flags.get(name) === "true";
+}
+function numberFlag(parsed, name) {
+    const value = flag(parsed, name);
+    if (value === undefined)
+        return undefined;
+    const parsedValue = Number(value);
+    if (!Number.isFinite(parsedValue))
+        throw new Error(`--${name} must be a number`);
+    return parsedValue;
+}
+function scopeFlag(parsed) {
+    const value = flag(parsed, "scope") ?? "user";
+    if (value !== "user" && value !== "project")
+        throw new Error("--scope must be user or project");
+    return value;
+}
+function sandboxFlag(parsed) {
+    const value = flag(parsed, "sandbox");
+    if (value === undefined)
+        return undefined;
+    if (value !== "read-only" && value !== "workspace-write")
+        throw new Error("-s/--sandbox must be read-only or workspace-write");
+    return value;
+}
+function kindFlag(parsed) {
+    const value = flag(parsed, "kind");
+    if (value === undefined)
+        return undefined;
+    if (value !== "note" && value !== "handoff" && value !== "decision")
+        throw new Error("--kind must be note, handoff, or decision");
+    return value;
+}
+function splitCsv(value) {
+    return value ? value.split(",").map(item => item.trim()).filter(Boolean) : undefined;
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:=+-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function printHelp() {
+    console.log(`codex-teams
+
+Usage:
+  codex-teams init [--preset review-panel|swarm|pipeline] [--out team.json]
+  codex-teams validate <team.json>
+  codex-teams doctor [--codex-home <dir>] [--json]
+  codex-teams install <team.json> [--codex-home <dir>] [--scope user|project] [--force] [--skip-model-check]
+  codex-teams uninstall <team-name> [--codex-home <dir>] [--scope user|project]
+  codex-teams leader-prompt <team.json> --goal <text>
+  codex-teams skill install|uninstall [--codex-home <dir>]
+  codex-teams run <team.json> --goal <text> [--execute --allow-codex] [-s workspace-write] [--timeout-sec N] [--stall-sec N]
+  codex-teams state init|show|finish <team>
+  codex-teams member bind <team> <member> --agent-id <id>
+  codex-teams task add|claim|complete|fail|list <team>
+  codex-teams note add|list <team>`);
+}

package/dist/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function assertConfinedRoot(root: string, base: string): string;
+export declare function isConfinedPath(candidate: string, root: string): boolean;

package/dist/paths.js

@@ -0,0 +1,53 @@
+import { existsSync, lstatSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+export function assertConfinedRoot(root, base) {
+    const basePath = resolve(base);
+    const rootPath = resolve(root);
+    if (!isPathInsideOrSame(rootPath, basePath)) {
+        throw new Error(`project-owned root escapes project: ${rootPath}`);
+    }
+    assertNoSymlinkComponents(rootPath, basePath);
+    const baseReal = realpathOrLogical(basePath);
+    const rootReal = existsSync(rootPath) ? realpathSync(rootPath) : rootPath;
+    if (existsSync(rootPath) && !isPathInsideOrSame(rootReal, baseReal)) {
+        throw new Error(`project-owned root resolves outside project: ${rootPath}`);
+    }
+    return rootPath;
+}
+export function isConfinedPath(candidate, root) {
+    const rootReal = realpathOrLogical(resolve(root));
+    const logicalCandidate = resolve(candidate);
+    const candidatePath = existsSync(logicalCandidate) ? realpathSync(logicalCandidate) : logicalCandidate;
+    return isPathInsideOrSame(candidatePath, rootReal) || isPathInsideOrSame(candidatePath, resolve(root));
+}
+function assertNoSymlinkComponents(rootPath, basePath) {
+    let current = basePath;
+    const rel = relative(basePath, rootPath);
+    if (!rel || rel === ".")
+        return;
+    if (rel.startsWith("..") || isAbsolute(rel))
+        throw new Error(`project-owned root escapes project: ${rootPath}`);
+    for (const part of rel.split(sep)) {
+        current = resolve(current, part);
+        if (!existsSync(current))
+            continue;
+        if (lstatSync(current).isSymbolicLink()) {
+            throw new Error(`project-owned root contains symlink component: ${current}`);
+        }
+    }
+}
+function realpathOrLogical(path) {
+    let current = path;
+    for (;;) {
+        if (existsSync(current))
+            return realpathSync(current);
+        const parent = dirname(current);
+        if (parent === current)
+            return path;
+        current = parent;
+    }
+}
+function isPathInsideOrSame(candidate, base) {
+    const rel = relative(base, candidate);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}

package/dist/prompt.d.ts

@@ -0,0 +1,3 @@
+import type { MemberDef, TeamDef } from "./types.js";
+export declare function assembleDeveloperInstructions(team: TeamDef, member: MemberDef): string;
+export declare function assembleLeaderPrompt(team: TeamDef, goal: string): string;