${Object.keys(HOSTS).join(\" | \")} (auto when omitted)\n --scope user | project (default: user)\n --pack catalog pack for list/compose, or target for enable/use\n --profile
model profile to stamp, or \"none\" (default: none)\n --model with \\`tier\\`: the model for that tier\n --thinking with \\`tier\\`: reasoning level, or \"none\" to clear\n --no-skill do not install the Staffed skill\n --link symlink instead of copy (dev workflow; excludes --profile)\n --force overwrite foreign or locally modified files\n --dry-run, -n print what would happen\n -h, --help this\n\nagent selection\n Agent-dependent commands probe ~/.pi/agent, ~/.codex, and ~/.claude when --agent is omitted.\n Exactly one installed agent is selected automatically. If multiple are installed,\n choose one with --agent. If none is installed, a warning is printed and Pi is used\n as the fallback. Agent-independent commands (help, list, compose, pack list,\n tier/models, validate) skip detection. Stateless list/compose default to the product\n catalog; pass --pack for another catalog. Use status for installed state.\n\nIn pi a persona is enabled purely by being present in an agents directory, so\nenable/disable place and remove files. Sources are never mutated: a model profile is\napplied while rendering, leaving the repo portable with no unpin step to forget.\nPlain enable inherits the parent model; a profile pins render-time defaults which a\ncall-site model can override. Agent selection and model profile are independent. For\ndurable tier edits, use a clone or persistent install.`;\n\nconst LABEL = {\n enabled: \"enabled\",\n disabled: \"-\",\n modified: \"modified locally\",\n replaced: \"replaced\",\n foreign: \"not ours\",\n missing: \"missing (was enabled)\",\n};\n\nfunction parse(argv) {\n const opts = { scope: \"user\", profile: \"none\", mode: \"copy\" };\n const rest = [];\n for (let i = 0; i < argv.length; i++) {\n const a = argv[i];\n const value = (option) => {\n const next = argv[i + 1];\n if (next === undefined || next.startsWith(\"-\")) throw new Error(`${option} requires a value`);\n i++;\n return next;\n };\n if (a === \"--agent\") opts.agent = value(\"--agent\");\n else if (a === \"--scope\") opts.scope = value(\"--scope\");\n else if (a === \"--pack\") opts.pack = value(\"--pack\");\n else if (a === \"--profile\") { opts.profile = value(\"--profile\"); opts.profileGiven = true; }\n else if (a === \"--model\") opts.model = value(\"--model\");\n else if (a === \"--compact\") opts.compact = true;\n else if (a === \"--thinking\") opts.thinking = value(\"--thinking\");\n else if (a === \"--no-skill\") opts.skill = false;\n else if (a === \"--link\") opts.mode = \"link\";\n else if (a === \"--copy\") opts.mode = \"copy\";\n else if (a === \"--force\") opts.force = true;\n else if (a === \"--dry-run\" || a === \"-n\") opts.dryRun = true;\n else if (a === \"-h\" || a === \"--help\") opts.help = true;\n else if (a.startsWith(\"-\")) throw new Error(`unknown option ${a}`);\n else rest.push(a);\n }\n if (![\"user\", \"project\"].includes(opts.scope)) throw new Error(\"--scope must be user or project\");\n return { opts, rest };\n}\n\n/** Wrap to ~86 columns with a hanging indent. */\nconst hang = (text, indent = \"\") => wrap(text, 86, indent);\n\nfunction warnUnverified(profile) {\n if (!profile?.unverified?.length) return;\n console.log();\n console.log(\n hang(\n `warning: tier(s) ${profile.unverified.join(\", \")} in profile \"${profile.key}\" were seeded by ` +\n \"guesswork and are not confirmed against a real install. Run `staffed doctor`, then \" +\n \"declare them with `staffed tier --model --thinking `.\",\n ),\n );\n}\n\nexport function printTiers(profileArg, cfg = loadConfig()) {\n const { key, map, unverified, fallbacks = [] } = resolveProfile(profileArg ?? true, cfg);\n console.log(`profile ${key}${profileArg ? \"\" : \" (default from models.json)\"}`);\n const rows = Object.entries(map).map(([tier, t]) => [\n tier,\n t.model,\n t.thinking ?? \"—\",\n [\n unverified.includes(tier) ? \"unverified\" : \"\",\n fallbacks.some((f) => f.tier === tier) ? \"compatibility fallback from balanced\" : \"\",\n ]\n .filter(Boolean)\n .join(\"; \"),\n ]);\n console.log(` ${table([[\"tier\", \"model\", \"thinking\", \"\"], ...rows]).split(\"\\n\").join(\"\\n \")}`);\n console.log(`\\nprofiles: ${Object.keys(cfg.profiles).join(\", \")}`);\n\n const prows = resolvePack(DEFAULT_PACK).personas.map((p) => [p.name, p.tier, p.effort, formatTier(map[p.tier])]);\n console.log();\n console.log(table(prows).split(\"\\n\").map((line) => ` ${line}`).join(\"\\n\"));\n warnUnverified({ key, unverified });\n if (fallbacks.length) {\n console.log(\n `\\ncompatibility: profile \"${key}\" has no explicit strong tier; declare it with ` +\n \"`staffed tier strong --model --thinking `.\",\n );\n }\n}\n\n/** The tier -> model:thinking map alone, for dropping into an agent's context. */\nexport function printTiersCompact(profileArg, cfg = loadConfig()) {\n const { key, map } = resolveProfile(profileArg ?? true, cfg);\n console.log(`profile ${key}`);\n console.log(table(Object.entries(map).map(([tier, t]) => [tier, formatTier(t)]))\n .split(\"\\n\").map((line) => ` ${line}`).join(\"\\n\"));\n}\n\n/** Compare configured models against what this pi install actually offers. */\nasync function doctor(agentName) {\n if (agentName !== \"pi\") {\n console.error(`doctor can inspect the Pi registry only; ${resolveHost(agentName).label} model availability cannot be verified here.`);\n return 1;\n }\n const cfg = loadConfig();\n console.log(`env PI_MODEL=${process.env.PI_MODEL ?? \"—\"} PI_REASONING_LEVEL=${process.env.PI_REASONING_LEVEL ?? \"—\"}`);\n console.log(` PI_PROVIDER=${process.env.PI_PROVIDER ?? \"—\"}`);\n\n let known = new Set();\n try {\n const m = JSON.parse(readFileSync(join(homedir(), \".pi\", \"agent\", \"models.json\"), \"utf8\"));\n for (const [provider, p] of Object.entries(m.providers ?? {})) {\n for (const x of p.models ?? []) {\n known.add(x.id);\n known.add(`${provider}/${x.id}`);\n }\n }\n } catch {\n console.log(\"\\ncould not read ~/.pi/agent/models.json — cannot verify model ids\");\n }\n if (process.env.PI_MODEL) {\n known.add(process.env.PI_MODEL);\n if (process.env.PI_PROVIDER) known.add(`${process.env.PI_PROVIDER}/${process.env.PI_MODEL}`);\n }\n\n console.log(`\\nmodels known to this install: ${known.size || \"none\"}`);\n for (const key of Object.keys(cfg.profiles)) {\n const { map, fallbacks = [] } = resolveProfile(key, cfg);\n console.log(`\\nprofile ${key}`);\n const rows = Object.entries(map).map(([tier, t]) => [\n tier,\n formatTier(t),\n `${known.size === 0 ? \"?\" : known.has(t.model) ? \"ok\" : \"NOT FOUND\"}${\n fallbacks.some((f) => f.tier === tier) ? \" (compatibility fallback from balanced)\" : \"\"\n }`,\n ]);\n console.log(table(rows).split(\"\\n\").map((line) => ` ${line}`).join(\"\\n\"));\n }\n console.log(\n \"\\nAvailability, including non-Pi and cross-provider profiles, depends on the providers installed in this Pi environment.\",\n );\n return 0;\n}\n\nfunction printStatus(s) {\n console.log(`agent ${s.host.label} (${s.host.key})`);\n console.log(`scope ${s.scope}`);\n console.log(`pack ${s.pack.key}${packSuffix(s.pack)}`);\n console.log(`dir ${s.dir}`);\n console.log(\n s.manifestError\n ? `manifest INVALID — ${s.manifestError}`\n : s.manifest\n ? `updated v${s.manifest.version}, ${s.manifest.updatedAt}`\n : \"manifest none — nothing enabled here\",\n );\n console.log();\n const rows = [\n [\"persona\", \"tier\", \"effort\", \"state\", \"installed\"],\n ...s.items.map((i) => [\n i.persona.name,\n i.persona.tier,\n i.persona.effort,\n LABEL[i.state] ?? i.state,\n modelOf(i),\n ]),\n ];\n console.log(table(rows).split(\"\\n\").map((line) => ` ${line}`).join(\"\\n\"));\n const enabled = s.items.filter((i) => i.state === \"enabled\").map((i) => i.persona.name);\n const drift = s.items.filter((i) => ![\"enabled\", \"disabled\"].includes(i.state));\n console.log(`\\n${enabled.length}/${s.items.length} enabled`);\n if (drift.length) console.log(`${drift.length} file(s) differ from the manifest`);\n\n const line = (label, item, missing) => {\n const text = {\n current: \"current\", stale: \"STALE — does not match what is enabled; re-run `staffed enable`\",\n absent: missing, disabled: missing, foreign: \"FOREIGN — not owned by Staffed\", modified: \"MODIFIED locally\",\n missing: \"MISSING — tracked item is absent\", replaced: \"REPLACED\",\n }[item.state] ?? item.state;\n console.log(`${label.padEnd(8)} ${text}\\n ${item.file ?? item.path}`);\n };\n line(\"skill\", s.skill, enabled.length ? \"MISSING — nothing tells the agent these personas exist\" : \"absent\");\n line(\"compose\", s.composition, enabled.length ? \"MISSING — composition details are unavailable\" : \"absent\");\n if (s.collisions?.length) console.log(`collisions ${s.collisions.map((c) => `${c.name}: ${c.path}`).join(\", \")}`);\n}\n\nconst modelOf = (i) => {\n if ([\"disabled\", \"foreign\"].includes(i.state)) return \"—\";\n if (i.tracked?.type === \"link\") return \"source link; model inherited\";\n if (i.tracked?.type !== \"copy\") return \"—\";\n if (!i.tracked.tier) return \"unknown (legacy manifest; re-enable to refresh)\";\n if (i.tracked.profile === \"none\" && !i.tracked.model) return `${i.tracked.tier} → inherited (none)`;\n if (!i.tracked.model) return \"unknown (incomplete manifest; re-enable to refresh)\";\n const value = i.tracked.thinking ? `${i.tracked.model}:${i.tracked.thinking}` : i.tracked.model;\n return `${i.tracked.tier} → ${value} (${i.tracked.profile ?? \"unknown\"})`;\n};\n\nfunction selectAgent(opts) {\n if (opts.agent !== undefined) return resolveHost(opts.agent);\n const selected = selectDefaultAgent();\n if (selected.reason === \"legacy-default\") {\n console.error(\n \"warning: no Pi, OpenAI Codex, or Claude Code configuration directory detected; defaulting to agent pi \" +\n \"(use --agent codex or --agent claude to choose another host)\",\n );\n }\n return resolveHost(selected.key);\n}\n\nfunction placementOptions(opts, host) {\n const { agent: _agent, ...rest } = opts;\n return { ...rest, host: host.key };\n}\n\nfunction validationProblems() {\n const catalog = loadCatalog();\n const problems = [...validateCatalog(catalog), ...validateModelConfig(loadConfig())];\n for (const name of packNames(catalog)) {\n let pack;\n try { pack = resolvePack(name, catalog); }\n catch (error) {\n if (!problems.some((problem) => problem.includes(error.message))) problems.push(`${name}: ${error.message}`);\n continue;\n }\n if (!Array.isArray(pack.stages) || !Array.isArray(pack.noArtifact) || !Array.isArray(pack.noDirectory)) continue;\n problems.push(...validate(pack.personas, pack.stages, { noArtifact: pack.noArtifact, noDirectory: pack.noDirectory }).map((problem) => `${name}: ${problem}`));\n }\n return problems;\n}\n\nfunction printPackList() {\n const rows = packNames().map((name) => {\n const pack = resolvePack(name);\n return [name, pack.experimental ? \"experimental preview\" : \"stable\", `${pack.label} (${pack.personas.length} roles)`];\n });\n console.log(table(rows).split(\"\\n\").map((line) => ` ${line}`).join(\"\\n\"));\n console.log(\"\\nProduct is the built-in default. An installed scope has exactly one active pack.\");\n}\n\nfunction printCompose(args, packName) {\n const pack = resolvePack(packName ?? DEFAULT_PACK);\n const dimensions = dimensionsFor(pack.key);\n const index = vocabularyIndex(pack.key);\n if (!args.length) {\n console.log(`Staffed composition catalog (stateless) — ${pack.label}${packSuffix(pack)}`);\n console.log(\"\\n [stance] [drive] [lens] [audience] [voice]\");\n console.log(\"\\nSelect one role and only the modifiers that materially change the result.\\n\");\n console.log(`roles: ${pack.personas.map((p) => p.name).join(\", \")}`);\n for (const dimension of dimensions) {\n if (dimension.name !== \"audience\") console.log(`${dimension.name}: ${dimension.modes.map((mode) => `${mode.name} (${mode.alias})`).join(\", \")}`);\n else {\n const names = new Set(pack.audiences.map((mode) => mode.name));\n console.log(`audience (core): ${dimension.modes.filter((mode) => !names.has(mode.name)).map((mode) => `${mode.name} (${mode.alias})`).join(\", \")}`);\n console.log(`audience (${pack.key}): ${pack.audiences.map((mode) => `${mode.name} (${mode.alias})`).join(\", \")}`);\n }\n }\n console.log(`\\nTry: staffed compose ${pack.recipes[0].composition.join(\" \")}`);\n console.log(\"Explore: staffed compose recipes | staffed compose lens | staffed compose sceptic\");\n console.log(\"This does not inspect installed state; pass --pack for another catalog or use status.\");\n return;\n }\n if (args.length === 1 && args[0].toLowerCase() === \"recipes\") {\n console.log(`${pack.label}${packSuffix(pack)} recipes\\n`);\n for (const recipe of pack.recipes) console.log(` ${recipe.name}\\n ${recipe.goal}\\n ${recipe.composition.join(\" + \")}\\n`);\n return;\n }\n if (args.length === 1) {\n const dimension = dimensions.find((item) => item.name === args[0].toLowerCase());\n if (dimension) {\n console.log(`${dimension.name} — ${dimension.question}\\n`);\n const packAudienceNames = new Set(pack.audiences.map((mode) => mode.name));\n for (const mode of dimension.modes) {\n const source = dimension.name === \"audience\" ? (packAudienceNames.has(mode.name) ? pack.key : \"core\") : \"core\";\n console.log(` ${mode.name} (${mode.alias})${dimension.name === \"audience\" ? ` [${source}]` : \"\"}\\n ${mode.summary}`);\n }\n return;\n }\n const entry = index.get(args[0].toLowerCase());\n if (entry && entry.dimension !== \"role\") {\n console.log(`${entry.name}\\ndimension ${entry.dimension}\\nalias ${entry.alias}\\n\\n${entry.summary}\\n\\nUseful for: ${entry.usefulFor}.\\nWatch for: ${entry.shadow}.`);\n return;\n }\n if (entry?.dimension === \"role\") {\n console.log(`${entry.name}\\nrole in ${pack.label}${packSuffix(pack)}\\n\\n${entry.summary}`);\n const recipes = pack.recipes.filter((recipe) => recipe.composition.includes(entry.name));\n if (recipes.length) console.log(`\\nRecipes:\\n${recipes.map((recipe) => ` ${recipe.composition.join(\" + \")}`).join(\"\\n\")}`);\n return;\n }\n }\n const composition = parseComposition(args, pack.key);\n console.log(`pack ${pack.key}${packSuffix(pack)}`);\n for (const dimension of [\"role\", \"stance\", \"drive\", \"lens\", \"audience\", \"voice\"]) {\n const entry = composition.selected[dimension];\n if (entry) console.log(`${dimension.padEnd(8)} ${entry.name}${entry.alias ? ` (${entry.alias})` : \"\"}`);\n }\n console.log(`\\n${compositionSentence(composition)}`);\n}\n\nfunction cmdList({ opts }) {\n const pack = resolvePack(opts.pack ?? DEFAULT_PACK);\n const rows = pack.personas.map((p) => [\n p.name,\n p.tier ?? \"?\",\n p.effort ?? \"?\",\n `${(p.meta.description ?? \"\").split(\". \")[0]}.`,\n ]);\n console.log(table(rows).split(\"\\n\").map((line) => ` ${line}`).join(\"\\n\"));\n console.log(`\\n${rows.length} personas — catalog pack ${pack.key}${packSuffix(pack)} (stateless; use status for installed state)`);\n return 0;\n}\n\nfunction cmdTier({ opts, names }) {\n const profile = opts.profileGiven ? opts.profile : undefined;\n if (opts.compact) {\n if (names.length) throw new Error(\"--compact takes no tier name\");\n if (opts.model !== undefined || opts.thinking !== undefined) throw new Error(\"--compact only prints; it cannot set a tier\");\n printTiersCompact(profile);\n return 0;\n }\n // `tier --profile X` with no tier name switches the default profile.\n if (!names.length && opts.model === undefined && opts.thinking === undefined) {\n if (opts.profile !== \"none\" && opts.profileGiven) {\n printTiers(setProfile(opts.profile));\n return 0;\n }\n printTiers();\n return 0;\n }\n if (!names.length) throw new Error(\"which tier? e.g. `staffed tier deep --model X --thinking xhigh`\");\n const r = setTier(profile ?? null, names[0], opts);\n console.log(`profile ${r.profile}: ${r.tier} -> ${formatTier(r.config)}\\n`);\n printTiers(r.profile);\n return 0;\n}\n\nfunction cmdValidate() {\n const problems = validationProblems();\n const count = packNames().reduce((total, name) => total + resolvePack(name).personas.length, 0);\n console.log(`${count} personas across ${packNames().length} packs`);\n if (!problems.length) {\n console.log(\"0 problems\");\n return 0;\n }\n console.error(`\\n${problems.length} problem(s):`);\n for (const p of problems) console.error(` - ${p}`);\n return 1;\n}\n\nfunction cmdPack(ctx) {\n const { opts, names } = ctx;\n if (!names.length || names[0] === \"list\") {\n printPackList();\n return 0;\n }\n const host = selectAgent(opts);\n if (names[0] !== \"use\" || !names[1] || names.length > 2) throw new Error(\"usage: staffed pack use \");\n const next = resolvePack(names[1]);\n const problems = validationProblems();\n if (problems.length) throw new Error(`refusing to switch — configuration has ${problems.length} problem(s)`);\n const r = placement.enable({ ...placementOptions(opts, host), pack: next.key, only: [] });\n console.log(`${r.dryRun ? \"would use\" : \"active pack\"} ${r.pack.key}${packSuffix(r.pack)} — ${r.dryRun ? r.items.length : r.enabledTotal} roles ${r.dryRun ? \"would be enabled\" : \"enabled\"} in ${r.dir}`);\n return 0;\n}\n\n/** Commands that probe the filesystem for an installed host before running. */\nconst dependent = (run) => (ctx) => {\n const host = selectAgent(ctx.opts);\n return run({ ...ctx, host, agentOpts: placementOptions(ctx.opts, host) });\n};\n\nconst cmdDoctor = dependent(({ host }) => doctor(host.key));\n\nconst cmdSkill = dependent(({ opts, host, agentOpts }) => {\n const current = placement.status(agentOpts);\n const enabled = current.items.filter((item) => item.state === \"enabled\").map((item) => item.persona.name);\n if (!enabled.length) {\n console.error(`nothing is enabled for agent ${host.label} (${opts.scope} scope).`);\n return 1;\n }\n console.log(`# would go in ${host.skillDir(opts.scope, process.cwd())}/staffed/SKILL.md\\n`);\n console.log(generateSkill({ hostKey: host.key, enabled, personas: current.pack.personas, pack: current.pack.key }));\n return 0;\n});\n\nconst cmdStatus = dependent(({ agentOpts }) => {\n printStatus(placement.status(agentOpts));\n return 0;\n});\n\nconst cmdEnable = dependent(({ opts, names, agentOpts }) => {\n const problems = validationProblems();\n if (problems.length) {\n console.error(`refusing to enable — configuration has ${problems.length} problem(s):`);\n for (const p of problems) console.error(` - ${p}`);\n return 1;\n }\n const r = placement.enable({ ...agentOpts, only: names });\n const verb = r.dryRun ? \"would enable\" : r.mode === \"link\" ? \"linked\" : \"enabled\";\n console.log(`${verb} ${r.items.length}${names.length ? \"\" : \" (all)\"} -> ${r.dir}`);\n console.log(\n `agent ${r.host.label}, scope ${r.scope}, pack ${r.pack.key}${packSuffix(r.pack)}, profile ${r.profile.key}, mode ${r.mode}` +\n (r.enabledTotal ? `, ${r.enabledTotal} enabled in total` : \"\"),\n );\n if (r.dryRun) for (const i of r.items) console.log(` ${i.file} (${LABEL[i.state] ?? i.state})`);\n\n const notes = [...(r.host.notes ?? [])];\n if (r.scope === \"project\") notes.push(\"This directory is committable — the roster travels with the repo.\");\n if (notes.length) {\n console.log(\"\\nnotes\");\n for (const n of notes) console.log(hang(n, \" \"));\n }\n warnUnverified(r.profile);\n return 0;\n});\n\nconst cmdDisable = dependent(({ names, agentOpts }) => {\n const r = placement.disable({ ...agentOpts, only: names });\n console.log(`disabled ${r.removed.length}${r.removed.length ? `: ${r.removed.join(\", \")}` : \"\"}`);\n console.log(`${r.remaining} still enabled in ${r.dir}`);\n\n if (r.kept.length) {\n console.log(`kept ${r.kept.length} locally modified: ${r.kept.join(\", \")} (use --force)`);\n }\n return 0;\n});\n\nconst COMMANDS = {\n help: { run: () => { console.log(HELP); return 0; } },\n list: { run: cmdList },\n compose: { run: ({ opts, names }) => { printCompose(names, opts.pack ?? DEFAULT_PACK); return 0; } },\n pack: { run: cmdPack },\n tier: { run: cmdTier },\n models: { run: cmdTier },\n validate: { run: cmdValidate },\n doctor: { run: cmdDoctor },\n skill: { run: cmdSkill },\n status: { run: cmdStatus },\n enable: { run: cmdEnable },\n install: { run: cmdEnable },\n disable: { run: cmdDisable },\n uninstall: { run: cmdDisable },\n};\n\nexport async function main(argv = process.argv.slice(2)) {\n const { opts, rest } = parse(argv);\n assertKnownHost(opts.agent);\n if (opts.help) {\n console.log(HELP);\n return 0;\n }\n const command = COMMANDS[rest[0] ?? \"help\"];\n if (!command) {\n console.error(`unknown command \"${rest[0]}\"\\n${HELP}`);\n return 2;\n }\n return command.run({ opts, argv, names: rest.slice(1) });\n}\n"}},"hosts.mjs":{"file":{"contents":"// Host registry. A host says where personas live and how their frontmatter is spelled.\n//\n// Adding a host means adding one entry. The bodies need no translation — they\n// deliberately contain nothing host-specific (no `subagent`, no `worktree`, no `.pi/`).\n\nimport { statSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\n\n/** Serialize frontmatter, folding description the way the sources do. */\nfunction frontmatter(fields) {\n const lines = [];\n for (const [key, value] of Object.entries(fields)) {\n if (value == null || value === \"\") continue;\n if (key === \"description\") {\n lines.push(\"description: >-\");\n let line = \"\";\n for (const word of String(value).split(/\\s+/)) {\n if (line && ` ${line} ${word}`.length > 82) {\n lines.push(` ${line}`);\n line = word;\n } else line = line ? `${line} ${word}` : word;\n }\n if (line) lines.push(` ${line}`);\n } else {\n lines.push(`${key}: ${value}`);\n }\n }\n return lines.join(\"\\n\");\n}\n\nconst render = (fields, body) => `---\\n${frontmatter(fields)}\\n---\\n${body}`;\n\n// How each host spells a resolved tier. This is the one genuine rendering difference\n// between hosts, and the reason tier config keeps model and thinking apart.\nconst piModel = (t) => (t ? (t.thinking ? `${t.model}:${t.thinking}` : t.model) : undefined);\nconst modelOnly = (t) => t?.model;\nconst codexTier = (tier) => {\n if (!tier) return undefined;\n const model = tier.model.match(/^(?:openai|openai-codex)\\/(.+)$/)?.[1];\n if (!model) throw new Error(`Codex requires an OpenAI provider model, got \"${tier.model}\"`);\n return { model, thinking: tier.thinking };\n};\nconst tomlString = (value) => JSON.stringify(String(value));\nconst codexHome = () => process.env.CODEX_HOME || join(homedir(), \".codex\");\nconst claudeTier = (tier) => {\n if (!tier) return undefined;\n if (!tier.model.startsWith(\"anthropic/\")) {\n throw new Error(`Claude Code requires an Anthropic provider model, got \"${tier.model}\"`);\n }\n const id = tier.model.slice(\"anthropic/\".length);\n const family = id.match(/^claude-(haiku|sonnet|opus)(?:-|$)/)?.[1];\n if (!family) throw new Error(`Anthropic model \"${tier.model}\" has no Claude Code family alias`);\n return { model: family, thinking: null };\n};\n\nexport const HOSTS = {\n pi: {\n label: \"pi\",\n supported: true,\n userDir: () => join(homedir(), \".pi\", \"agent\", \"agents\"),\n projectDir: (cwd) => join(cwd, \".pi\", \"agents\"),\n // Skills are the discovery mechanism: pi puts their descriptions in the system prompt.\n skillDir: (scope, cwd) => (scope === \"project\" ? join(cwd, \".pi\", \"skills\") : join(homedir(), \".pi\", \"agent\", \"skills\")),\n filename: (p) => `${p.name}.md`,\n render: (p, tier) => render({ name: p.name, description: p.meta.description, model: piModel(tier) }, p.body),\n notes: [\n 'subagent defaults to agentScope: \"user\", so project-scope installs are invisible until a call passes agentScope: \"both\".',\n \"Personas cannot ship via `pi install`: a pi package carries extensions, skills, prompts and themes only, never agents.\",\n ],\n },\n\n codex: {\n label: \"OpenAI Codex\",\n // Codex CLI and the desktop app share these user/project configuration conventions.\n supported: true,\n allowedProfiles: [\"none\", \"openai\"],\n userDir: () => join(codexHome(), \"agents\"),\n projectDir: (cwd) => join(cwd, \".codex\", \"agents\"),\n skillDir: (scope, cwd) => (scope === \"project\" ? join(cwd, \".agents\", \"skills\") : join(homedir(), \".agents\", \"skills\")),\n filename: (p) => `${p.name}.toml`,\n mapTier: codexTier,\n render: (p, tier) =>\n [\n `name = ${tomlString(p.name)}`,\n `description = ${tomlString('Staffed role; use only after $staffed, \"use Staffed\", or \"staff this project\". Never select for ordinary prompts. ' + p.meta.description)}`,\n ...(tier?.model ? [`model = ${tomlString(tier.model)}`] : []),\n ...(tier?.thinking ? [`model_reasoning_effort = ${tomlString(tier.thinking)}`] : []),\n `developer_instructions = ${tomlString(p.body)}`,\n \"\",\n ].join(\"\\n\"),\n notes: [\n \"Supports Codex CLI and the Codex experience in the ChatGPT desktop app.\",\n \"Custom agents are TOML files under .codex/agents; Staffed's Markdown persona bodies are preserved as developer_instructions.\",\n \"Skills use the shared .agents/skills location required by Codex.\",\n ],\n },\n\n claude: {\n label: \"Claude Code\",\n // Claude Desktop's Code tab reads the same .claude configuration as the CLI.\n // Chat and Cowork are separate surfaces and are not targets of this host.\n supported: true,\n allowedProfiles: [\"none\", \"anthropic\"],\n userDir: () => join(homedir(), \".claude\", \"agents\"),\n projectDir: (cwd) => join(cwd, \".claude\", \"agents\"),\n skillDir: (scope, cwd) => (scope === \"project\" ? join(cwd, \".claude\", \"skills\") : join(homedir(), \".claude\", \"skills\")),\n filename: (p) => `${p.name}.md`,\n mapTier: claudeTier,\n render: (p, tier) =>\n render(\n {\n name: p.name,\n description:\n 'Staffed role; use only after /staffed, \"use Staffed\", or \"staff this project\". Never select for ordinary prompts. ' +\n p.meta.description,\n model: modelOnly(tier),\n },\n p.body,\n ),\n notes: [\n \"Supports Claude Code CLI and the Code tab in Claude Desktop; Chat and Cowork are separate surfaces.\",\n \"The anthropic profile renders as Claude Code's opus/sonnet/haiku family aliases.\",\n \"Has no per-agent thinking level, so the thinking half of a tier is dropped.\",\n ],\n },\n opencode: {\n label: \"opencode\",\n supported: false,\n userDir: () => join(homedir(), \".config\", \"opencode\", \"agent\"),\n projectDir: (cwd) => join(cwd, \".opencode\", \"agent\"),\n skillDir: (scope, cwd) => (scope === \"project\" ? join(cwd, \".opencode\", \"skills\") : join(homedir(), \".config\", \"opencode\", \"skills\")),\n filename: (p) => `${p.name}.md`,\n render: (p, tier) =>\n render({ name: p.name, description: p.meta.description, mode: \"subagent\", model: modelOnly(tier) }, p.body),\n notes: [\"Adds `mode: subagent`, the only frontmatter delta in the whole roster.\"],\n },\n};\n\nexport const DEFAULT_HOST = \"pi\";\n\nfunction isDirectory(path) {\n try {\n return statSync(path).isDirectory();\n } catch (error) {\n if ([\"ENOENT\", \"ENOTDIR\"].includes(error?.code)) return false;\n throw error;\n }\n}\n\nexport function selectDefaultAgent({ home = homedir(), env = process.env } = {}) {\n const detected = [];\n if (isDirectory(join(home, \".pi\", \"agent\"))) detected.push(\"pi\");\n if (isDirectory(env.CODEX_HOME || join(home, \".codex\"))) detected.push(\"codex\");\n if (isDirectory(join(home, \".claude\"))) detected.push(\"claude\");\n if (detected.length > 1) {\n throw new Error(`multiple agent hosts were detected (${detected.join(\", \")}); pass --agent ${detected.join(\" or --agent \")}`);\n }\n return detected.length\n ? { key: detected[0], detected, reason: \"detected\" }\n : { key: DEFAULT_HOST, detected, reason: \"legacy-default\" };\n}\n\nexport function resolveHost(name = DEFAULT_HOST) {\n const host = HOSTS[name];\n if (!host) {\n throw new Error(`unknown agent \"${name}\". known: ${Object.keys(HOSTS).join(\", \")}`);\n }\n if (!host.supported) {\n throw new Error(\n `agent \"${name}\" is not supported yet (target: ${host.userDir()}).\\n` +\n `The rendering seam exists — implement and verify it, then flip supported: true in src/hosts.mjs.`,\n );\n }\n return { key: name, ...host };\n}\n\n/** Early validation for commands that may never reach resolveHost. */\nexport function assertKnownHost(name) {\n if (name !== undefined && !Object.hasOwn(HOSTS, name)) {\n throw new Error(`unknown agent \"${name}\". known: ${Object.keys(HOSTS).join(\", \")}`);\n }\n}\n\nexport function targetDir(host, scope, cwd) {\n return scope === \"project\" ? host.projectDir(cwd) : host.userDir();\n}\n"}},"install.mjs":{"file":{"contents":"import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, symlinkSync, writeFileSync } from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { dirname, isAbsolute, join, relative, resolve, sep } from \"node:path\";\nimport { ROOT } from \"./personas.mjs\";\nimport { DEFAULT_PACK, resolvePack } from \"./packs.mjs\";\nimport { resolveProfile, tierFor } from \"./models.mjs\";\nimport { resolveHost, targetDir } from \"./hosts.mjs\";\nimport { compositionReferencePath, generateCompositionReference, generateSkill, skillPath } from \"./skill.mjs\";\nimport { hashText, inspectFile, normalizeManifest, removeDecision, writeDecision } from \"./ownership.mjs\";\n\nconst MANIFEST = \".staffed.json\";\nconst pkgVersion = () => JSON.parse(readFileSync(join(ROOT, \"package.json\"), \"utf8\")).version;\nconst isEphemeral = (p) => p.includes(\"/_npx/\") || p.includes(\"/dlx-\") || p.startsWith(tmpdir());\nconst pathExists = (path) => { try { lstatSync(path); return true; } catch (error) { if (error?.code === \"ENOENT\") return false; throw error; } };\n\nfunction referenceAncestorProblem(path) {\n const staffedDir = dirname(dirname(path));\n for (const ancestor of [staffedDir, dirname(path)]) {\n if (!pathExists(ancestor)) continue;\n const stat = lstatSync(ancestor);\n if (stat.isSymbolicLink() || !stat.isDirectory()) return ancestor;\n }\n return null;\n}\n\nfunction skillAncestorProblem(path) {\n const ancestor = dirname(path);\n if (!pathExists(ancestor)) return null;\n const stat = lstatSync(ancestor);\n return stat.isSymbolicLink() || !stat.isDirectory() ? ancestor : null;\n}\n\nfunction assertSafeDiscoveryAncestor(kind, path) {\n const unsafe = kind.ancestorProblem(path);\n if (unsafe) throw new Error(kind.refuses(unsafe));\n}\n\nfunction inspectDiscoveryFile(kind, path, record) {\n const unsafeAncestor = kind.ancestorProblem(path);\n return unsafeAncestor\n ? { path, record, state: \"replaced\", unsafeAncestor }\n : inspectFile(path, record);\n}\n\nfunction removeEmptyDirectory(path) {\n try { rmdirSync(path); } catch (error) { if (![\"ENOENT\", \"ENOTEMPTY\", \"EEXIST\"].includes(error?.code)) throw error; }\n}\n\n/**\n * Project configuration is repository-controlled. Never follow one of its managed\n * directory ancestors through a symlink (or a non-directory) before mutating role or\n * discovery files. User-scope config may intentionally live behind home-directory\n * symlinks, so this boundary is deliberately project-only.\n */\nfunction assertSafeProjectMutationPaths(scope, cwd, paths) {\n if (scope !== \"project\") return;\n const root = resolve(cwd);\n for (const target of paths) {\n const parent = dirname(resolve(target));\n const rel = relative(root, parent);\n if (isAbsolute(rel) || rel === \"..\" || rel.startsWith(`..${sep}`)) {\n throw new Error(`refusing to mutate project-managed path outside ${root}: ${target}`);\n }\n let current = root;\n for (const part of rel.split(sep).filter(Boolean)) {\n current = join(current, part);\n if (!pathExists(current)) continue;\n const stat = lstatSync(current);\n if (stat.isSymbolicLink() || !stat.isDirectory()) {\n throw new Error(`refusing to mutate project files through symlink or non-directory ancestor ${current}`);\n }\n }\n }\n}\n\nfunction assertSafeDiscoveryTarget(path) {\n if (pathExists(path) && lstatSync(path).isDirectory() && readdirSync(path).length) {\n throw new Error(`refusing to replace non-empty discovery directory ${path}`);\n }\n}\n\nfunction removeDiscoveryTarget(path) {\n if (!pathExists(path)) return;\n if (lstatSync(path).isDirectory()) rmdirSync(path);\n else rmSync(path, { force: true });\n}\n\nfunction atomicReplace(path, content, mode) {\n mkdirSync(dirname(path), { recursive: true });\n const temp = join(dirname(path), `.${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`);\n try {\n writeFileSync(temp, content, { flag: \"wx\", ...(mode === undefined ? {} : { mode }) });\n if (mode !== undefined) chmodSync(temp, mode);\n if (pathExists(path) && lstatSync(path).isDirectory()) rmdirSync(path);\n renameSync(temp, path);\n } catch (error) {\n rmSync(temp, { force: true });\n throw error;\n }\n}\n\nfunction transactionalMutation(paths, mutate) {\n const entries = [...new Set(paths)].map((path, index) => ({\n path,\n backup: join(dirname(path), `.staffed-backup-${process.pid}-${Date.now()}-${index}-${Math.random().toString(16).slice(2)}`),\n existed: pathExists(path),\n }));\n const staged = [];\n try {\n for (const entry of entries) {\n if (entry.existed) renameSync(entry.path, entry.backup);\n staged.push(entry);\n }\n } catch (error) {\n for (const entry of staged) if (entry.existed && pathExists(entry.backup)) renameSync(entry.backup, entry.path);\n throw error;\n }\n let result;\n try {\n result = mutate();\n } catch (error) {\n for (const entry of [...staged].reverse()) rmSync(entry.path, { recursive: true, force: true });\n for (const entry of staged) {\n if (entry.existed && pathExists(entry.backup)) renameSync(entry.backup, entry.path);\n }\n throw error;\n }\n for (const entry of staged) if (entry.existed) rmSync(entry.backup, { recursive: true, force: true });\n return result;\n}\n\nfunction loadManifest(dir, context, { diagnostic = false } = {}) {\n const file = join(dir, MANIFEST);\n if (!existsSync(file)) return { manifest: null, manifestError: null };\n try {\n const raw = JSON.parse(readFileSync(file, \"utf8\"));\n return { manifest: normalizeManifest(raw, context), manifestError: null };\n } catch (error) {\n if (!diagnostic) throw new Error(`invalid Staffed manifest ${file}: ${error.message}`);\n return { manifest: null, manifestError: error.message };\n }\n}\n\nfunction select(personas, only) {\n if (!only?.length) return personas;\n const known = new Map(personas.map((p) => [p.name, p]));\n const unknown = only.filter((n) => !known.has(n));\n if (unknown.length) throw new Error(`unknown agent(s): ${unknown.join(\", \")}\\nroster: ${personas.map((p) => p.name).join(\" \")}`);\n return only.map((n) => known.get(n));\n}\n\nfunction validateProfile(host, profile) {\n if (host.allowedProfiles && !host.allowedProfiles.includes(profile.key)) {\n throw new Error(`profile \"${profile.key}\" is not valid for ${host.label}; use ${host.allowedProfiles.join(\", \")}`);\n }\n}\n\nfunction recursiveAgentFiles(dir, extension, out = []) {\n if (!existsSync(dir)) return out;\n for (const entry of readdirSync(dir, { withFileTypes: true })) {\n const path = join(dir, entry.name);\n if (entry.isSymbolicLink()) continue;\n if (entry.isDirectory()) recursiveAgentFiles(path, extension, out);\n else if (entry.isFile() && entry.name.endsWith(extension)) out.push(path);\n }\n return out;\n}\n\nfunction codexDeclaredName(text, path) {\n // Multiline TOML strings can contain assignment-looking lines. Without a full\n // parser we cannot distinguish those safely, so reject the file before scanning.\n if (text.includes('\\\"\\\"\\\"') || text.includes(\"'''\")) {\n throw new Error(`cannot safely inspect Codex agent name in ${path}`);\n }\n const assignment = text.match(/^(?:name|\"name\"|'name')\\s*=\\s*(.+)$/m);\n // Codex treats the parsed TOML `name` field as authoritative. If a foreign\n // agent uses a key/value spelling this dependency-free reader cannot decode\n // conclusively, refuse the install rather than risk missing a collision.\n if (!assignment) throw new Error(`cannot safely inspect Codex agent name in ${path}`);\n const raw = assignment[1].trim();\n if (raw.startsWith(\"'\")) {\n const literal = raw.match(/^'([^']*)'\\s*(?:#.*)?$/);\n if (literal) return literal[1];\n } else if (raw.startsWith('\"') && !raw.startsWith('\\\"\\\"\\\"')) {\n let escaped = false;\n for (let i = 1; i < raw.length; i++) {\n if (escaped) { escaped = false; continue; }\n if (raw[i] === \"\\\\\") { escaped = true; continue; }\n if (raw[i] !== '\"') continue;\n const suffix = raw.slice(i + 1).trim();\n if (suffix && !suffix.startsWith(\"#\")) break;\n try { return JSON.parse(raw.slice(0, i + 1)); } catch { break; }\n }\n }\n throw new Error(`cannot safely inspect Codex agent name in ${path}`);\n}\n\nfunction declaredName(host, path) {\n try {\n const text = readFileSync(path, \"utf8\");\n return host.key === \"codex\"\n ? codexDeclaredName(text, path)\n : text.match(/^name:\\s*([^\\n]+)$/m)?.[1]?.trim() ?? null;\n } catch (error) {\n if (host.key === \"codex\" && /cannot safely inspect/.test(error.message)) throw error;\n return null;\n }\n}\n\nfunction collisions(host, dir, items) {\n const extension = host.key === \"claude\" ? \".md\" : host.key === \"codex\" ? \".toml\" : null;\n if (!extension) return [];\n const targets = new Set(items.map((i) => i.path));\n const names = new Set(items.map((i) => i.persona.name));\n return recursiveAgentFiles(dir, extension).flatMap((path) => {\n const name = declaredName(host, path);\n return name && names.has(name) && !targets.has(path) ? [{ name, path }] : [];\n });\n}\n\nexport function plan({ host: hostName, scope = \"user\", profile = \"none\", mode = \"copy\", only, pack: requestedPack, cwd = process.cwd() }) {\n const host = resolveHost(hostName);\n const prof = resolveProfile(profile);\n validateProfile(host, prof);\n const dir = targetDir(host, scope, cwd);\n const { manifest, manifestError } = loadManifest(dir, { hostKey: host.key, scope });\n const activePack = manifest?.pack ?? DEFAULT_PACK;\n const pack = resolvePack(requestedPack ?? activePack);\n const previousPack = resolvePack(activePack);\n const switching = Boolean(manifest && pack.key !== activePack);\n const personas = pack.personas;\n if (mode === \"link\" && prof.map) throw new Error(\"--link cannot be combined with a model profile: a rendered file is not a link to the source.\");\n if (mode === \"link\" && [\"claude\", \"codex\"].includes(host.key)) throw new Error(`--link is unavailable for ${host.label} because its host-specific agent format must be rendered.`);\n if (mode === \"link\" && isEphemeral(ROOT)) throw new Error(`--link refused: this package lives in an ephemeral directory (${ROOT}).\\nLinks would break as soon as the cache is cleared. Use the default copy mode, or clone the repo and link from there.`);\n const items = select(personas, only).map((persona) => {\n const file = host.filename(persona), path = join(dir, file);\n const profileTier = tierFor(persona, prof);\n const tier = host.mapTier ? host.mapTier(profileTier) : profileTier;\n return { persona, file, path, tier, content: mode === \"link\" ? null : host.render(persona, tier), ...inspectFile(path, manifest?.files[file]) };\n });\n const previousItems = switching ? previousPack.personas.map((persona) => {\n const file = host.filename(persona), path = join(dir, file);\n return { persona, file, path, ...inspectFile(path, manifest?.files[file]) };\n }) : [];\n return { host, scope, profile: prof, mode, dir, items, manifest, manifestError, personas, pack, previousPack, switching, previousItems, collisions: collisions(host, dir, items) };\n}\n\nfunction recordFor(p, item) {\n if (p.mode === \"link\") return { type: \"link\", target: join(ROOT, p.pack.agentsDir, item.persona.file) };\n return { type: \"copy\", hash: hashText(item.content), profile: p.profile.key, tier: item.persona.tier,\n ...(item.tier ? { model: item.tier.model } : {}), ...(item.tier?.thinking != null ? { thinking: item.tier.thinking } : {}) };\n}\n\nfunction writeManifest(p, files, discovery, references = p.manifest?.references ?? {}) {\n const value = { schema: 2, package: \"staffed\", version: pkgVersion(), host: p.host.key, scope: p.scope, source: ROOT,\n pack: p.pack?.key ?? p.manifest?.pack ?? DEFAULT_PACK, updatedAt: new Date().toISOString(), files, ...(Object.keys(discovery).length ? { discovery } : {}), ...(Object.keys(references).length ? { references } : {}) };\n writeFileSync(join(p.dir, MANIFEST), `${JSON.stringify(value, null, 2)}\\n`);\n return value;\n}\n\nfunction healthyNames(host, dir, files, pack) {\n return pack.personas.filter((persona) => inspectFile(join(dir, host.filename(persona)), files[host.filename(persona)]).state === \"enabled\").map((p) => p.name);\n}\n\n// Discovery artifacts: rendered files that make an installed roster discoverable by\n// its host session. Every lifecycle step below treats them uniformly through this table.\nconst DISCOVERY_KINDS = [\n {\n key: \"skill\",\n section: \"discovery\",\n path: (dir) => skillPath(dir),\n content: ({ hostKey, names, pack }) => generateSkill({ hostKey, enabled: names, personas: pack.personas, pack: pack.key }),\n ancestorProblem: skillAncestorProblem,\n refuses: (ancestor) => `refusing to access Staffed skill through symlink or non-directory ancestor ${ancestor}`,\n },\n {\n key: \"composition\",\n section: \"references\",\n path: (dir) => compositionReferencePath(dir),\n content: ({ names, pack }) => generateCompositionReference({ pack: pack.key, personas: pack.personas.filter((p) => names.includes(p.name)) }),\n ancestorProblem: referenceAncestorProblem,\n refuses: (ancestor) => `refusing to access composition reference through symlink or non-directory ancestor ${ancestor}`,\n },\n];\n\nfunction discoveryStatus(host, scope, cwd, manifest, names, pack) {\n const status = {};\n for (const kind of DISCOVERY_KINDS) {\n const path = kind.path(host.skillDir(scope, cwd));\n const content = kind.content({ hostKey: host.key, names, pack });\n const inspected = inspectDiscoveryFile(kind, path, manifest?.[kind.section]?.[kind.key]);\n const state = inspected.state === \"enabled\"\n ? (readFileSync(path, \"utf8\") === content ? \"current\" : \"stale\")\n : inspected.state;\n status[kind.key] = { kind, path, record: inspected.record, unsafeAncestor: inspected.unsafeAncestor, state, content };\n }\n return status;\n}\n\nexport function enable(opts) {\n const p = plan(opts); const { force = false, dryRun = false } = opts;\n if (p.collisions.length) throw new Error(`${p.host.label} agent name collision(s):\\n${p.collisions.map((c) => ` ${c.name}: ${c.path}`).join(\"\\n\")}`);\n if (p.switching && opts.skill === false && DISCOVERY_KINDS.some((kind) => p.manifest?.[kind.section]?.[kind.key])) {\n throw new Error(\"--no-skill cannot switch a pack that has tracked discovery; switch normally, then disable discovery if needed\");\n }\n const blocked = p.items.filter((i) => writeDecision(i.state, { force }) === \"block\");\n if (p.switching) {\n const foreignPrevious = p.previousItems.filter((item) => item.state === \"foreign\");\n if (foreignPrevious.length) {\n throw new Error(`refusing to switch while unowned ${p.previousPack.key} role file(s) remain:\\n${foreignPrevious.map((item) => ` ${item.path}`).join(\"\\n\")}\\nMove or remove them explicitly; --force never deletes unowned files.`);\n }\n for (const item of p.previousItems) {\n const decision = removeDecision(item.state, { force });\n if (decision === \"keep\") blocked.push(item);\n }\n }\n const files = p.switching ? {} : { ...(p.manifest?.files ?? {}) };\n const selected = new Set(p.items.map((item) => item.persona.name));\n for (const item of p.items) files[item.file] = recordFor(p, item);\n const names = p.personas\n .filter((persona) => selected.has(persona.name) || (!p.switching && inspectFile(join(p.dir, p.host.filename(persona)), p.manifest?.files?.[p.host.filename(persona)]).state === \"enabled\"))\n .map((persona) => persona.name);\n const cwd = opts.cwd ?? process.cwd();\n const d = discoveryStatus(p.host, p.scope, cwd, p.manifest, names, p.pack);\n const desired = opts.skill !== false ? Object.values(d) : [];\n assertSafeProjectMutationPaths(p.scope, cwd, [\n join(p.dir, MANIFEST),\n ...p.items.map((item) => item.path),\n ...p.previousItems.map((item) => item.path),\n ...desired.map((item) => item.path),\n ]);\n for (const item of desired) {\n if ([\"foreign\", \"modified\", \"replaced\"].includes(item.state) && !force) blocked.push(item);\n }\n if (blocked.length) throw new Error(`refusing to overwrite ${blocked.length} unowned or modified item(s):\\n${blocked.map((i) => ` ${i.file ?? i.path}`).join(\"\\n\")}\\nRe-run with --force to overwrite.`);\n for (const item of desired) {\n assertSafeDiscoveryAncestor(item.kind, item.path);\n assertSafeDiscoveryTarget(item.path);\n }\n if (dryRun) return { ...p, wrote: [], dryRun: true };\n mkdirSync(p.dir, { recursive: true });\n const transactionPaths = [\n join(p.dir, MANIFEST),\n ...p.items.map((item) => item.path),\n ...p.previousItems.map((item) => item.path),\n ...desired.map((item) => item.path),\n ];\n const committed = transactionalMutation(transactionPaths, () => {\n const tracked = {\n discovery: { ...(p.manifest?.discovery ?? {}) },\n references: { ...(p.manifest?.references ?? {}) },\n };\n for (const item of desired) {\n atomicReplace(item.path, item.content);\n tracked[item.kind.section][item.kind.key] = { type: \"copy\", hash: hashText(item.content) };\n }\n const wrote = [];\n if (p.switching) {\n const incoming = new Set(p.items.map((item) => item.path));\n for (const item of p.previousItems) if (!incoming.has(item.path)) rmSync(item.path, { recursive: true, force: true });\n }\n for (const item of p.items) {\n if (pathExists(item.path)) rmSync(item.path, { recursive: true, force: true });\n if (p.mode === \"link\") symlinkSync(join(ROOT, p.pack.agentsDir, item.persona.file), item.path); else writeFileSync(item.path, item.content);\n wrote.push(item.file);\n }\n return { wrote, manifest: writeManifest(p, files, tracked.discovery, tracked.references) };\n });\n return { ...p, ...committed, enabledTotal: Object.keys(files).length, skill: d.skill, composition: d.composition };\n}\n\nexport function disable(opts) {\n const p = plan({ ...opts, mode: \"copy\", profile: \"none\" });\n if (!p.manifest) throw new Error(`nothing enabled by Staffed in ${p.dir}`);\n if (p.switching) throw new Error(`pack \"${p.previousPack.key}\" is active; switch packs with \\`staffed pack use ${p.pack.key}\\` before disabling its roles`);\n const cwd = opts.cwd ?? process.cwd();\n const skillDir = p.host.skillDir(p.scope, cwd);\n const trackedDiscovery = DISCOVERY_KINDS.filter((kind) => p.manifest[kind.section]?.[kind.key]);\n const mutationPaths = [join(p.dir, MANIFEST), ...p.items.map((item) => item.path)];\n if (opts.skill !== false) for (const kind of trackedDiscovery) mutationPaths.push(kind.path(skillDir));\n assertSafeProjectMutationPaths(p.scope, cwd, mutationPaths);\n // Validate discovery targets before the first mutation so expected failures are atomic.\n if (opts.skill !== false) {\n for (const kind of trackedDiscovery) {\n const path = kind.path(skillDir);\n assertSafeDiscoveryAncestor(kind, path);\n if (opts.force) assertSafeDiscoveryTarget(path);\n }\n }\n if (opts.dryRun) return { ...p, removed: [], kept: [], remaining: Object.keys(p.manifest.files).length, dryRun: true };\n const discovery = { ...(p.manifest.discovery ?? {}) };\n const files = { ...p.manifest.files }, removed = [], kept = [];\n for (const item of p.items) {\n const inspected = inspectFile(item.path, files[item.file]);\n const decision = removeDecision(inspected.state, { force: opts.force });\n if (decision === \"remove\") { rmSync(item.path, { recursive: true, force: true }); delete files[item.file]; removed.push(item.file); }\n else if (decision === \"prune\") delete files[item.file];\n else if (decision === \"keep\") kept.push(item.file);\n }\n const names = healthyNames(p.host, p.dir, files, p.pack);\n const references = { ...(p.manifest.references ?? {}) };\n const d = discoveryStatus(p.host, p.scope, cwd, { ...p.manifest, files, discovery }, names, p.pack);\n if (opts.skill !== false) {\n const tracked = { discovery, references };\n for (const kind of trackedDiscovery) {\n const record = tracked[kind.section][kind.key], item = d[kind.key];\n const raw = inspectFile(item.path, record);\n const decision = removeDecision(raw.state, { force: opts.force });\n if (!names.length) {\n if (decision === \"remove\") {\n removeDiscoveryTarget(item.path);\n removeEmptyDirectory(dirname(item.path));\n delete tracked[kind.section][kind.key];\n } else if (decision === \"prune\") delete tracked[kind.section][kind.key];\n } else if (raw.state === \"enabled\" || (opts.force && [\"modified\", \"replaced\"].includes(raw.state))) {\n atomicReplace(item.path, item.content);\n tracked[kind.section][kind.key] = { type: \"copy\", hash: hashText(item.content) };\n }\n }\n }\n\n if (!names.length) removeEmptyDirectory(dirname(skillPath(p.host.skillDir(p.scope, cwd))));\n if (Object.keys(files).length || Object.keys(discovery).length || Object.keys(references).length) writeManifest(p, files, discovery, references); else rmSync(join(p.dir, MANIFEST), { force: true });\n return { dir: p.dir, removed, kept, remaining: Object.keys(files).length, pack: p.pack, skill: d.skill, composition: d.composition };\n}\n\nexport function status({ host: hostName, scope = \"user\", cwd = process.cwd() } = {}) {\n const host = resolveHost(hostName), dir = targetDir(host, scope, cwd);\n const loaded = loadManifest(dir, { hostKey: host.key, scope }, { diagnostic: true });\n const manifest = loaded.manifest;\n let manifestError = loaded.manifestError;\n let pack;\n try { pack = resolvePack(manifest?.pack ?? DEFAULT_PACK); }\n catch (error) { manifestError = error.message; pack = resolvePack(DEFAULT_PACK); }\n const items = pack.personas.map((persona) => { const file = host.filename(persona); return { persona, file, ...inspectFile(join(dir, file), manifest?.files?.[file]), tracked: manifest?.files?.[file] }; });\n const names = items.filter((i) => i.state === \"enabled\").map((i) => i.persona.name);\n const discovery = discoveryStatus(host, scope, cwd, manifest, names, pack);\n return { host, scope, dir, pack, manifest, manifestError, items, collisions: collisions(host, dir, items), ...discovery };\n}\n"}},"models.mjs":{"file":{"contents":"// Tier -> { model, thinking } resolution. models.json is the only file that changes\n// when models do. Thinking is kept separate from the model name because hosts spell it\n// differently: pi wants a `model:level` suffix, others have no per-agent notion of it.\n\nimport { readFileSync, writeFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { ROOT, TIERS } from \"./personas.mjs\";\n\nconst FILE = join(ROOT, \"models.json\");\n\nexport const loadConfig = () => JSON.parse(readFileSync(FILE, \"utf8\"));\nconst saveConfig = (cfg) => writeFileSync(FILE, `${JSON.stringify(cfg, null, 2)}\\n`);\n\n/** Accept \"model\", \"model:thinking\" or { model, thinking }. */\nexport function normalizeTier(value) {\n if (value == null) return null;\n let model;\n let thinking = null;\n if (typeof value === \"string\") {\n const i = value.lastIndexOf(\":\");\n model = i === -1 ? value : value.slice(0, i);\n thinking = i === -1 ? null : value.slice(i + 1);\n } else if (typeof value === \"object\" && !Array.isArray(value)) {\n model = value.model;\n thinking = value.thinking ?? null;\n } else {\n throw new Error(`tier config needs a \"model\": got ${JSON.stringify(value)}`);\n }\n if (typeof model !== \"string\" || !model.trim()) {\n throw new Error(`tier config needs a non-empty \"model\": got ${JSON.stringify(value)}`);\n }\n if (thinking !== null && (typeof thinking !== \"string\" || !thinking.trim())) {\n throw new Error(`tier config has invalid \"thinking\": got ${JSON.stringify(value)}`);\n }\n return { model, thinking };\n}\n\nexport const formatTier = (t) => (t == null ? \"—\" : t.thinking ? `${t.model}:${t.thinking}` : t.model);\n\n// Tiers every profile must define. `strong` is optional and falls back to balanced.\nconst REQUIRED_TIERS = [\"fast\", \"balanced\", \"deep\"];\n\n/**\n * Resolve a profile name to a tier -> { model, thinking } map.\n * `\"none\"` yields a null map, meaning \"stamp no model at all\" — the host default\n * applies, or the orchestrator passes one at the call site.\n */\nexport function resolveProfile(name, cfg) {\n if (name === \"none\" || name == null) return { key: \"none\", map: null };\n cfg ??= loadConfig();\n const key = name === true ? cfg.profile : name;\n const raw = cfg.profiles?.[key];\n if (!raw) {\n throw new Error(`unknown profile \"${key}\". models.json has: ${Object.keys(cfg.profiles ?? {}).join(\", \")}`);\n }\n\n const missing = REQUIRED_TIERS.filter((t) => !raw[t]);\n if (missing.length) throw new Error(`profile \"${key}\" is missing tier(s): ${missing.join(\", \")}`);\n\n const fallbacks = [];\n const map = {};\n const hasStrong = Object.hasOwn(raw, \"strong\");\n for (const tier of TIERS) {\n const source = tier === \"strong\" && !hasStrong ? raw.balanced : raw[tier];\n const normalized = normalizeTier(source);\n if (!normalized) throw new Error(`profile \"${key}\" has an invalid tier \"${tier}\"`);\n map[tier] = { ...normalized };\n if (tier === \"strong\" && !hasStrong) fallbacks.push({ tier: \"strong\", from: \"balanced\" });\n }\n return {\n key,\n map,\n unverified: cfg.unverified?.[key] ?? [],\n ...(fallbacks.length ? { fallbacks } : {}),\n };\n}\n\nconst PROFILE_PROVIDERS = {\n anthropic: [\"anthropic\"],\n openai: [\"openai\", \"openai-codex\"],\n \"openai-deepseek\": [\"openai\", \"openai-codex\", \"deepseek\"],\n};\nconst PROFILE_KEYS = Object.keys(PROFILE_PROVIDERS);\n\nfunction modelProvider(model) {\n return model.match(/^([^/]+)\\//)?.[1];\n}\n\nfunction matchesProfileProvider(profile, model) {\n const provider = modelProvider(model);\n return provider != null && PROFILE_PROVIDERS[profile]?.includes(provider);\n}\n\nfunction profileProviderLabel(profile) {\n return PROFILE_PROVIDERS[profile]?.join(\", \") ?? profile;\n}\n\n/** Validate one tier value against its profile's provider set, collecting problems. */\nfunction checkTier(problems, key, tier, raw) {\n try {\n const normalized = normalizeTier(raw[tier]);\n if (!normalized) throw new Error(\"tier config must not be null\");\n if (!matchesProfileProvider(key, normalized.model)) {\n problems.push(\n `models.json: profile \"${key}\" tier \"${tier}\" must use a model from the ${profileProviderLabel(key)} provider set`,\n );\n }\n } catch (error) {\n problems.push(`models.json: profile \"${key}\" tier \"${tier}\": ${error.message}`);\n }\n}\n\n/** Validate models.json structure without reading or writing disk. */\nexport function validateModelConfig(cfg) {\n const problems = [];\n const profiles = cfg?.profiles;\n if (!profiles || typeof profiles !== \"object\" || Array.isArray(profiles)) {\n return [\"models.json: profiles must be an object\"];\n }\n const keys = Object.keys(profiles);\n for (const key of PROFILE_KEYS) {\n if (!Object.hasOwn(profiles, key)) problems.push(`models.json: missing canonical profile \"${key}\"`);\n }\n for (const key of keys) {\n if (!PROFILE_KEYS.includes(key)) {\n problems.push(`models.json: unsupported profile \"${key}\"; use ${PROFILE_KEYS.join(\", \")}`);\n }\n }\n if (typeof cfg.profile !== \"string\" || !profiles[cfg.profile]) {\n problems.push(`models.json: default profile \"${cfg.profile ?? \"\"}\" does not exist`);\n }\n for (const [key, raw] of Object.entries(profiles)) {\n if (!raw || typeof raw !== \"object\" || Array.isArray(raw)) {\n problems.push(`models.json: profile \"${key}\" must be an object`);\n continue;\n }\n for (const tier of REQUIRED_TIERS) {\n if (raw[tier] == null) {\n problems.push(`models.json: profile \"${key}\" is missing tier \"${tier}\"`);\n continue;\n }\n checkTier(problems, key, tier, raw);\n }\n if (Object.hasOwn(raw, \"strong\")) checkTier(problems, key, \"strong\", raw);\n }\n return problems;\n}\n\n/** Declare what a tier means. Writes models.json. */\nexport function setTier(profileKey, tier, { model, thinking }) {\n if (!TIERS.includes(tier)) throw new Error(`unknown tier \"${tier}\". known: ${TIERS.join(\", \")}`);\n const cfg = loadConfig();\n const key = profileKey ?? cfg.profile;\n if (!cfg.profiles?.[key]) throw new Error(`unknown profile \"${key}\"`);\n\n const current = normalizeTier(cfg.profiles[key][tier]) ?? { model: null, thinking: null };\n const next = {\n model: model ?? current.model,\n thinking: thinking === \"none\" ? null : (thinking ?? current.thinking),\n };\n if (!next.model) throw new Error(`tier \"${tier}\" has no model yet — pass --model`);\n if (!matchesProfileProvider(key, next.model)) {\n throw new Error(`profile \"${key}\" requires a model from the ${profileProviderLabel(key)} provider set`);\n }\n\n cfg.profiles[key][tier] = next.thinking ? next : { model: next.model };\n // A tier the user has now declared by hand is no longer an unverified guess of ours.\n if (cfg.unverified?.[key]) {\n cfg.unverified[key] = cfg.unverified[key].filter((t) => t !== tier);\n if (!cfg.unverified[key].length) delete cfg.unverified[key];\n if (!Object.keys(cfg.unverified).length) delete cfg.unverified;\n }\n saveConfig(cfg);\n return { profile: key, tier, config: next };\n}\n\n/** Set the default profile. */\nexport function setProfile(key) {\n const cfg = loadConfig();\n if (!PROFILE_KEYS.includes(key) || !cfg.profiles?.[key]) throw new Error(`unknown profile \"${key}\"`);\n cfg.profile = key;\n saveConfig(cfg);\n return key;\n}\n\n/** The tier config to stamp for a persona, or undefined to omit the field. */\nexport const tierFor = (persona, profile) => (profile?.map ? profile.map[persona.tier] : undefined);\n"}},"ownership.mjs":{"file":{"contents":"import { createHash } from \"node:crypto\";\nimport { lstatSync, readFileSync, readlinkSync } from \"node:fs\";\n\nexport const hashText = (text) => createHash(\"sha256\").update(text).digest(\"hex\").slice(0, 16);\n\nconst lstat = (path) => {\n try { return lstatSync(path); } catch (error) {\n if (error?.code === \"ENOENT\") return null;\n throw error;\n }\n};\n\nexport function inspectFile(path, record) {\n const stat = lstat(path);\n if (!stat) return { path, record, state: record ? \"missing\" : \"disabled\" };\n if (!record) return { path, record, state: \"foreign\" };\n if (stat.isSymbolicLink()) {\n if (record.type !== \"link\") return { path, record, state: \"replaced\" };\n return { path, record, state: readlinkSync(path) === record.target ? \"enabled\" : \"replaced\" };\n }\n if (!stat.isFile() || record.type !== \"copy\") return { path, record, state: \"replaced\" };\n return { path, record, state: hashText(readFileSync(path, \"utf8\")) === record.hash ? \"enabled\" : \"modified\" };\n}\n\nexport function writeDecision(state, { force = false } = {}) {\n return [\"foreign\", \"modified\", \"replaced\"].includes(state) && !force ? \"block\" : \"allow\";\n}\n\nexport function removeDecision(state, { force = false } = {}) {\n if (state === \"enabled\") return \"remove\";\n if (state === \"missing\") return \"prune\";\n if ([\"modified\", \"replaced\"].includes(state)) return force ? \"remove\" : \"keep\";\n return \"noop\";\n}\n\nconst object = (value) => value && typeof value === \"object\" && !Array.isArray(value);\nconst HASH = /^[a-f0-9]{16}$/;\n\nfunction validateRecord(record, allowedTypes, label) {\n if (!object(record) || !allowedTypes.includes(record.type)) throw new Error(`${label} is invalid`);\n if (record.type === \"link\" && (typeof record.target !== \"string\" || !record.target)) {\n throw new Error(`${label}.target must be a non-empty string`);\n }\n if ([\"copy\", \"block\"].includes(record.type) && (typeof record.hash !== \"string\" || !HASH.test(record.hash))) {\n throw new Error(`${label}.hash must be a 16-character lowercase sha256 prefix`);\n }\n}\n\nfunction fileRecords(value) {\n if (!object(value)) throw new Error(\"manifest files must be an object\");\n for (const [name, record] of Object.entries(value)) validateRecord(record, [\"copy\", \"link\"], `manifest files.${name}`);\n return value;\n}\n\nfunction discoveryRecords(value) {\n if (!object(value)) throw new Error(\"manifest discovery must be an object\");\n for (const [name, record] of Object.entries(value)) {\n if (name === \"skill\") validateRecord(record, [\"copy\"], \"manifest discovery.skill\");\n else throw new Error(`manifest discovery.${name} is not supported`);\n }\n return value;\n}\n\nfunction referenceRecords(value) {\n if (!object(value)) throw new Error(\"manifest references must be an object\");\n for (const [name, record] of Object.entries(value)) {\n if (name === \"composition\") validateRecord(record, [\"copy\"], \"manifest references.composition\");\n else throw new Error(`manifest references.${name} is not supported`);\n }\n return value;\n}\n\nexport function normalizeManifest(raw, { hostKey, scope }) {\n if (!object(raw)) throw new Error(\"manifest must be an object\");\n if (raw.package !== \"staffed\") throw new Error('manifest package must be \"staffed\"');\n if (raw.schema != null && raw.schema !== 2) throw new Error(`unsupported manifest schema ${raw.schema}`);\n if (raw.host !== hostKey) throw new Error(`manifest host is ${raw.host ?? \"missing\"}, expected ${hostKey}`);\n if (raw.scope !== scope) throw new Error(`manifest scope is ${raw.scope ?? \"missing\"}, expected ${scope}`);\n if (raw.pack != null && (typeof raw.pack !== \"string\" || !raw.pack)) throw new Error(\"manifest pack must be a non-empty string\");\n const legacy = raw.schema == null;\n const discovery = Object.hasOwn(raw, \"discovery\") ? discoveryRecords(raw.discovery) : {};\n const references = Object.hasOwn(raw, \"references\") ? referenceRecords(raw.references) : {};\n return {\n ...raw,\n schema: 2,\n files: fileRecords(raw.files),\n discovery: legacy ? {} : discovery,\n references: legacy ? {} : references,\n pack: raw.pack ?? \"product\",\n legacy,\n legacyPack: raw.pack == null,\n };\n}\n"}},"packs.mjs":{"file":{"contents":"// Staff-pack and composition catalog. catalog.json is the single source of truth;\n// this module supplies loading, validation, lookup, and presentation-neutral parsing.\n\nimport { readFileSync } from \"node:fs\";\nimport { isAbsolute, join, relative, resolve } from \"node:path\";\nimport { ROOT, loadPersonas } from \"./personas.mjs\";\n\nexport const DEFAULT_PACK = \"product\";\nexport const CATALOG_FILE = join(ROOT, \"catalog.json\");\n\n/** The label suffix used wherever a pack name is printed. */\nexport const packSuffix = (pack) => (pack.experimental ? \" (experimental preview)\" : \"\");\n\nlet cached;\nexport function loadCatalog(file = CATALOG_FILE) {\n if (file === CATALOG_FILE && cached) return cached;\n const value = JSON.parse(readFileSync(file, \"utf8\"));\n if (file === CATALOG_FILE) cached = value;\n return value;\n}\n\nconst object = (value) => value && typeof value === \"object\" && !Array.isArray(value);\nconst string = (value) => typeof value === \"string\" && value.trim().length > 0;\n\nexport function packNames(catalog = loadCatalog()) {\n return object(catalog?.packs) ? Object.keys(catalog.packs) : [];\n}\n\nfunction agentsDirectory(value) {\n if (!string(value) || isAbsolute(value)) return null;\n const path = resolve(ROOT, value);\n const fromRoot = relative(ROOT, path);\n return fromRoot && !fromRoot.startsWith(`..${process.platform === \"win32\" ? \"\\\\\" : \"/\"}`) && fromRoot !== \"..\" ? path : null;\n}\n\nexport function resolvePack(name = DEFAULT_PACK, catalog = loadCatalog()) {\n const key = String(name || DEFAULT_PACK).toLowerCase();\n const definition = object(catalog?.packs) ? catalog.packs[key] : null;\n if (!object(definition)) throw new Error(`unknown pack \"${name}\". known: ${packNames(catalog).join(\", \")}`);\n const directory = agentsDirectory(definition.agentsDir);\n if (!directory) throw new Error(`pack \"${key}\" has no safe relative agentsDir`);\n const personas = loadPersonas(directory);\n return { key, ...definition, personas };\n}\n\nexport function dimensionsFor(packName = DEFAULT_PACK, catalog = loadCatalog()) {\n const pack = resolvePack(packName, catalog);\n if (!Array.isArray(catalog?.dimensions)) throw new Error(\"catalog dimensions must be an array\");\n return catalog.dimensions.map((dimension) => ({\n ...dimension,\n modes: dimension.name === \"audience\" ? [...dimension.modes, ...(pack.audiences ?? [])] : dimension.modes,\n }));\n}\n\nexport function vocabularyFor(packName = DEFAULT_PACK, catalog = loadCatalog()) {\n const pack = resolvePack(packName, catalog);\n const entries = pack.personas.map((persona) => ({\n name: persona.name,\n alias: null,\n dimension: \"role\",\n summary: persona.meta.description,\n persona,\n }));\n for (const dimension of dimensionsFor(packName, catalog)) {\n for (const mode of dimension.modes) entries.push({ ...mode, dimension: dimension.name });\n }\n return entries;\n}\n\nconst keyOf = (value) => String(value).toLowerCase();\n\nexport function vocabularyIndex(packName = DEFAULT_PACK, catalog = loadCatalog()) {\n const entries = vocabularyFor(packName, catalog);\n const index = new Map();\n for (const entry of entries) {\n index.set(keyOf(entry.name), entry);\n if (entry.alias) index.set(keyOf(entry.alias), entry);\n }\n return index;\n}\n\nfunction distance(a, b) {\n const rows = Array.from({ length: a.length + 1 }, (_, i) => [i]);\n for (let j = 1; j <= b.length; j++) rows[0][j] = j;\n for (let i = 1; i <= a.length; i++) {\n for (let j = 1; j <= b.length; j++) {\n rows[i][j] = Math.min(\n rows[i - 1][j] + 1,\n rows[i][j - 1] + 1,\n rows[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1),\n );\n }\n }\n return rows[a.length][b.length];\n}\n\nfunction suggestion(token, entries) {\n const names = entries.flatMap((entry) => [entry.name, entry.alias].filter(Boolean));\n const ranked = names.map((name) => [name, distance(keyOf(token), keyOf(name))]).sort((a, b) => a[1] - b[1] || a[0].localeCompare(b[0]));\n const threshold = Math.max(2, Math.floor(String(token).length / 3));\n return ranked[0]?.[1] <= threshold ? ranked[0][0] : null;\n}\n\nexport function parseComposition(tokens, packName = DEFAULT_PACK, catalog = loadCatalog()) {\n const pack = resolvePack(packName, catalog);\n const entries = vocabularyFor(packName, catalog);\n const index = vocabularyIndex(packName, catalog);\n const selected = {};\n for (const token of tokens) {\n const entry = index.get(keyOf(token));\n if (!entry) {\n const hint = suggestion(token, entries);\n throw new Error(`unknown composition option \"${token}\"${hint ? `. Did you mean \"${hint}\"?` : ` for pack \"${pack.key}\". Run \\`staffed compose${pack.key === DEFAULT_PACK ? \"\" : ` --pack ${pack.key}`}\\` to see known choices`}`);\n }\n if (selected[entry.dimension]) {\n if (selected[entry.dimension].name === entry.name) continue;\n throw new Error(\n `composition selects two ${entry.dimension} modes: \"${selected[entry.dimension].name}\" and \"${entry.name}\"; choose one`,\n );\n }\n selected[entry.dimension] = entry;\n }\n if (!selected.role) throw new Error(`composition needs one role from pack \"${pack.key}\": ${pack.personas.map((p) => p.name).join(\", \")}`);\n return { pack, selected };\n}\n\nexport function compositionSentence(composition) {\n const { selected } = composition;\n const phrases = [\"stance\", \"drive\", \"lens\", \"audience\", \"voice\"]\n .map((name) => selected[name]?.phrase)\n .filter(Boolean);\n if (!phrases.length) return `Use ${selected.role.name} with its plain role defaults.`;\n const joined = phrases.length === 1 ? phrases[0] : `${phrases.slice(0, -1).join(\", \")}, and ${phrases.at(-1)}`;\n return `Use ${selected.role.name} to ${joined}.`;\n}\n\nexport function validateCatalog(catalog = loadCatalog()) {\n const problems = [];\n if (!object(catalog)) return [\"catalog must be an object\"];\n if (catalog.schema !== 1) problems.push(\"catalog schema must be 1\");\n\n const add = (map, token, label) => {\n if (!string(token)) { problems.push(`${label} must be a non-empty string`); return; }\n const key = keyOf(token);\n if (map.has(key)) problems.push(`${label} \"${token}\" collides with ${map.get(key)}`);\n else map.set(key, label);\n };\n const requireString = (owner, field, label) => {\n if (!string(owner?.[field])) problems.push(`${label}.${field} must be a non-empty string`);\n };\n const requireArray = (owner, field, label) => {\n if (!Array.isArray(owner?.[field])) { problems.push(`${label}.${field} must be an array`); return false; }\n return true;\n };\n const validateMode = (mode, label, tokens) => {\n if (!object(mode)) { problems.push(`${label} must be an object`); return; }\n for (const field of [\"name\", \"alias\", \"summary\", \"usefulFor\", \"shadow\", \"phrase\"]) requireString(mode, field, label);\n add(tokens, mode.name, `${label}.name`);\n add(tokens, mode.alias, `${label}.alias`);\n };\n\n const dimensionNames = new Set();\n const coreTokens = new Map();\n if (requireArray(catalog, \"dimensions\", \"catalog\")) {\n for (const [index, dimension] of catalog.dimensions.entries()) {\n const label = `dimensions[${index}]`;\n if (!object(dimension)) { problems.push(`${label} must be an object`); continue; }\n requireString(dimension, \"name\", label);\n requireString(dimension, \"question\", label);\n if (string(dimension.name)) {\n if (dimensionNames.has(dimension.name)) problems.push(`duplicate dimension \"${dimension.name}\"`);\n dimensionNames.add(dimension.name);\n }\n if (requireArray(dimension, \"modes\", label)) {\n for (const [modeIndex, mode] of dimension.modes.entries()) validateMode(mode, `${label}.modes[${modeIndex}]`, coreTokens);\n }\n }\n }\n for (const required of [\"stance\", \"drive\", \"lens\", \"audience\", \"voice\"]) {\n if (!dimensionNames.has(required)) problems.push(`catalog is missing required dimension \"${required}\"`);\n }\n\n if (!object(catalog.packs)) {\n problems.push(\"catalog.packs must be an object\");\n return problems;\n }\n for (const [packName, definition] of Object.entries(catalog.packs)) {\n const label = `packs.${packName}`;\n if (!object(definition)) { problems.push(`${label} must be an object`); continue; }\n for (const field of [\"label\", \"description\", \"agentsDir\", \"riskGate\"]) requireString(definition, field, label);\n if (typeof definition.experimental !== \"boolean\") problems.push(`${label}.experimental must be a boolean`);\n for (const field of [\"stages\", \"noArtifact\", \"noDirectory\", \"audiences\", \"recipes\", \"sizing\", \"loops\", \"parallelism\", \"activationExamples\"]) requireArray(definition, field, label);\n if (Array.isArray(definition.activationExamples)) {\n if (!definition.activationExamples.length || !definition.activationExamples.every(string)) problems.push(`${label}.activationExamples must contain non-empty strings`);\n }\n\n let pack = null;\n if (string(definition.agentsDir)) {\n try { pack = resolvePack(packName, catalog); }\n catch (error) { problems.push(`${label}: ${error.message}`); }\n }\n const roleNames = new Set(pack?.personas?.map((persona) => persona.name) ?? []);\n const tokens = new Map(coreTokens);\n for (const persona of pack?.personas ?? []) add(tokens, persona.name, `${label}.role.${persona.name}`);\n\n const stageNames = new Set();\n if (Array.isArray(definition.stages)) {\n for (const [index, stage] of definition.stages.entries()) {\n const stageLabel = `${label}.stages[${index}]`;\n if (!object(stage)) { problems.push(`${stageLabel} must be an object`); continue; }\n requireString(stage, \"name\", stageLabel);\n requireString(stage, \"role\", stageLabel);\n if (stage.parallel != null && typeof stage.parallel !== \"boolean\") problems.push(`${stageLabel}.parallel must be a boolean`);\n if (string(stage.name)) {\n if (stageNames.has(stage.name)) problems.push(`${label}.stages has duplicate role \"${stage.name}\"`);\n stageNames.add(stage.name);\n if (pack && !roleNames.has(stage.name)) problems.push(`${label}.${stage.name}: stage has no role`);\n }\n }\n }\n for (const name of roleNames) if (!stageNames.has(name)) problems.push(`${label}.${name}: role is not in the pack stages`);\n\n for (const field of [\"noArtifact\", \"noDirectory\"]) {\n if (!Array.isArray(definition[field])) continue;\n const seen = new Set();\n for (const [index, name] of definition[field].entries()) {\n if (!string(name)) problems.push(`${label}.${field}[${index}] must be a non-empty string`);\n else if (seen.has(name)) problems.push(`${label}.${field} contains duplicate role \"${name}\"`);\n else {\n seen.add(name);\n if (pack && !roleNames.has(name)) problems.push(`${label}.${field} references unknown role \"${name}\"`);\n }\n }\n }\n\n if (Array.isArray(definition.audiences)) {\n for (const [index, audience] of definition.audiences.entries()) validateMode(audience, `${label}.audiences[${index}]`, tokens);\n }\n\n const recipeNames = new Set();\n if (Array.isArray(definition.recipes)) {\n for (const [index, recipe] of definition.recipes.entries()) {\n const recipeLabel = `${label}.recipes[${index}]`;\n if (!object(recipe)) { problems.push(`${recipeLabel} must be an object`); continue; }\n requireString(recipe, \"name\", recipeLabel);\n requireString(recipe, \"goal\", recipeLabel);\n if (string(recipe.name)) {\n if (recipeNames.has(recipe.name)) problems.push(`${label}.recipes has duplicate name \"${recipe.name}\"`);\n recipeNames.add(recipe.name);\n }\n if (!Array.isArray(recipe.composition) || !recipe.composition.every(string)) {\n problems.push(`${recipeLabel}.composition must be an array of non-empty strings`);\n } else if (pack && Array.isArray(catalog.dimensions)) {\n try { parseComposition(recipe.composition, packName, catalog); }\n catch (error) { problems.push(`${recipeLabel}: ${error.message}`); }\n }\n }\n }\n\n if (Array.isArray(definition.sizing)) {\n for (const [index, item] of definition.sizing.entries()) {\n const itemLabel = `${label}.sizing[${index}]`;\n if (!object(item)) { problems.push(`${itemLabel} must be an object`); continue; }\n requireString(item, \"work\", itemLabel);\n if (item.chain !== null && (!Array.isArray(item.chain) || !item.chain.length || !item.chain.every(string))) {\n problems.push(`${itemLabel}.chain must be null or a non-empty array of role names`);\n } else if (Array.isArray(item.chain)) {\n for (const role of item.chain) if (pack && !roleNames.has(role)) problems.push(`${itemLabel}.chain references unknown role \"${role}\"`);\n }\n }\n }\n\n for (const field of [\"loops\", \"parallelism\"]) {\n if (!Array.isArray(definition[field])) continue;\n for (const [index, item] of definition[field].entries()) {\n const itemLabel = `${label}.${field}[${index}]`;\n if (!object(item)) { problems.push(`${itemLabel} must be an object`); continue; }\n requireString(item, \"text\", itemLabel);\n if (!Array.isArray(item.requires) || !item.requires.length || !item.requires.every(string)) {\n problems.push(`${itemLabel}.requires must be a non-empty array of role names`);\n } else {\n for (const role of item.requires) if (pack && !roleNames.has(role)) problems.push(`${itemLabel}.requires references unknown role \"${role}\"`);\n }\n }\n }\n }\n return problems;\n}\n"}},"personas.mjs":{"file":{"contents":"// Reading, parsing and validating the roster. The persona files are the source of\n// truth for everything except which concrete model a tier maps to.\n\nimport { readFileSync, readdirSync } from \"node:fs\";\nimport { fileURLToPath } from \"node:url\";\nimport { dirname, join } from \"node:path\";\n\nexport const ROOT = join(dirname(fileURLToPath(import.meta.url)), \"..\");\nexport const AGENTS_DIR = join(ROOT, \"agents\");\nexport const TIERS = [\"fast\", \"balanced\", \"strong\", \"deep\"];\nexport const EFFORTS = [\"low\", \"medium\", \"high\"];\n\n// Product defaults. Other staff packs pass their own exceptions to validate().\nconst PRODUCT_NO_ARTIFACT = [\"reviewer\"];\nconst PRODUCT_NO_DIRECTORY = [\"reviewer\", \"builder\"];\n\n/** Split a persona file into frontmatter text and body. */\nfunction split(text) {\n const m = text.match(/^---\\n([\\s\\S]*?)\\n---\\n([\\s\\S]*)$/);\n if (!m) return null;\n return { fm: m[1], body: m[2] };\n}\n\n/** Flat scalar/folded-scalar frontmatter reader. Enough for name/description/model. */\nfunction readFrontmatter(fm) {\n const out = {};\n const lines = fm.split(\"\\n\");\n for (let i = 0; i < lines.length; i++) {\n const m = lines[i].match(/^([a-zA-Z_][\\w-]*):\\s*(.*)$/);\n if (!m) continue;\n const [, key, rest] = m;\n if (rest === \">-\" || rest === \">\" || rest === \"|\" || rest === \"|-\") {\n const folded = [];\n while (i + 1 < lines.length && /^\\s+\\S/.test(lines[i + 1])) folded.push(lines[++i].trim());\n out[key] = folded.join(\" \");\n } else {\n out[key] = rest.replace(/^[\"']|[\"']$/g, \"\");\n }\n }\n return out;\n}\n\n/** Defaults are Markdown body sections so persona files stay portable across hosts. */\nfunction readDefault(body, heading, values, label) {\n const line = body.match(new RegExp(`^# ${heading}\\\\n(.*)$`, \"m\"))?.[1];\n if (!line) return { value: null, reason: `no \"# ${heading}\" section` };\n const value = line.match(/`([a-z]+)`/)?.[1];\n if (!values.includes(value)) {\n return { value: null, reason: `${label} must be a backticked ${values.join(\"|\")} — got: ${line.trim()}` };\n }\n return { value };\n}\n\nfunction readTier(body) {\n const heading = /^# Default model tier$/m.test(body) ? \"Default model tier\" : \"Recommended model tier\";\n const { value, reason } = readDefault(body, heading, TIERS, \"tier\");\n return { tier: value, reason };\n}\n\nfunction readEffort(body) {\n const { value, reason } = readDefault(body, \"Default effort\", EFFORTS, \"effort\");\n return { effort: value, reason };\n}\n\n/** Load every persona. Returns { name, file, meta, body, tier, text }. */\nexport function loadPersonas(dir = AGENTS_DIR) {\n return readdirSync(dir)\n .filter((f) => f.endsWith(\".md\"))\n .sort()\n .map((file) => {\n const text = readFileSync(join(dir, file), \"utf8\");\n const parts = split(text);\n const name = file.replace(/\\.md$/, \"\");\n if (!parts) return { name, file, text, meta: {}, body: \"\", tier: null, broken: \"no frontmatter\" };\n const tier = readTier(parts.body);\n const effort = readEffort(parts.body);\n return {\n name,\n file,\n text,\n fm: parts.fm,\n body: parts.body,\n meta: readFrontmatter(parts.fm),\n tier: tier.tier,\n effort: effort.effort,\n broken: [tier.reason, effort.reason].filter(Boolean).join(\"; \") || null,\n };\n });\n}\n\n/** Structural checks. Returns an array of human-readable problems. */\nexport function validate(personas, stages, { noArtifact = PRODUCT_NO_ARTIFACT, noDirectory = PRODUCT_NO_DIRECTORY } = {}) {\n const problems = [];\n const names = personas.map((p) => p.name);\n const noArtifactSet = new Set(noArtifact);\n const noDirectorySet = new Set(noDirectory);\n\n // The generated skill uses this canonical stage order for roster routing; it must\n // cover the roster exactly so every installed persona remains discoverable.\n if (stages) {\n const staged = stages.map((s) => s.name);\n for (const n of names) if (!staged.includes(n)) problems.push(`${n}: in the roster but not in the pipeline order`);\n for (const s of staged) if (!names.includes(s)) problems.push(`${s}: in the pipeline order but not in the roster`);\n }\n\n for (const p of personas) {\n const at = (msg) => problems.push(`${p.file}: ${msg}`);\n if (p.broken) at(p.broken);\n if (p.meta.name !== p.name) at(`frontmatter name \"${p.meta.name ?? \"\"}\" does not match filename`);\n if (!p.meta.description) at(\"no description\");\n if (p.meta.tools) at(\"declares a tools allowlist (containment here is prompt-level)\");\n if (p.meta.model) at(\"has a pinned model — pinning belongs at install time, not in source\");\n if (!/^# Output \\(always in this structure, unless escalating\\)/m.test(p.body)) at(\"no output contract\");\n if (!/^# Effort and output budget/m.test(p.body)) at(\"no effort and output budget\");\n if (!noArtifactSet.has(p.name) && !/^# Artifact/m.test(p.body)) at(\"no # Artifact section\");\n\n if (!noDirectorySet.has(p.name) && !p.body.includes(`artifacts/${p.name}/`)) {\n at(`never references its own artifacts/${p.name}/`);\n }\n for (const other of names) {\n if (other === p.name || noDirectorySet.has(other)) continue;\n if (new RegExp(`writ\\\\w+[^.]{0,40}artifacts/${other}/`).test(p.body)) {\n at(`appears to write into artifacts/${other}/`);\n }\n }\n }\n return problems;\n}\n"}},"skill.mjs":{"file":{"contents":"// The Staffed skill: how a host session learns the roster exists and how to run it.\n//\n// Agents are invisible — `subagent` surfaces them only in error messages. Skills are the\n// inverse: pi puts every skill's name and description in the system prompt at startup and\n// loads the body on demand. So the skill is the discovery mechanism, and the personas are\n// the workers it dispatches.\n//\n// The description is deliberately written as a gate rather than an invitation. Whether a\n// piece of work deserves a staffed workflow is a question about intent, which lives with\n// the user and is not inferable from a prompt, so the model is told to wait to be asked.\n// Keeping the skill visible (rather than disable-model-invocation) is what lets \"use the\n// \"staff this project\" work in plain English instead of requiring a slash command.\n\nimport { join } from \"node:path\";\nimport { DEFAULT_PACK, packSuffix, dimensionsFor, resolvePack } from \"./packs.mjs\";\nimport { wrap } from \"./text.mjs\";\n\nexport const SKILL_NAME = \"staffed\";\n\n/** Skill prose flows at 88 columns. */\nconst flow = (text, width) => wrap(text, width ?? 88);\n\nfunction chain(stages) {\n const parts = [];\n for (let i = 0; i < stages.length; i++) {\n const s = stages[i];\n if (s.parallel && stages[i + 1]?.parallel) {\n parts.push(`\\`${s.name}\\` and \\`${stages[++i].name}\\``);\n } else parts.push(`\\`${s.name}\\``);\n }\n return parts.join(\" → \");\n}\n\n/** Generate SKILL.md for a specific set of enabled personas. */\nexport function generateSkill({ hostKey = \"pi\", enabled, personas = [], pack: packName = DEFAULT_PACK, catalog }) {\n const claude = hostKey === \"claude\";\n const codex = hostKey === \"codex\";\n const codexOrClaude = codex || claude;\n const invocation = claude ? \"/staffed\" : codex ? \"$staffed\" : \"/skill:staffed\";\n const workerLabel = claude ? \"Agent\" : codex ? \"Codex subagent\" : \"subagent\";\n const dispatchTool = claude ? \"Agent\" : codex ? \"Codex subagents\" : \"the `subagent` tool\";\n const pack = resolvePack(packName, catalog);\n const set = new Set(enabled);\n const stages = pack.stages.filter((s) => set.has(s.name));\n const partial = stages.length < pack.stages.length;\n const has = (n) => set.has(n);\n const persona = (n) => personas.find((p) => p.name === n);\n const blurb = (n) => persona(n)?.summary ?? \"\";\n const enabledRoleNames = stages.map((stage) => stage.name);\n const configuredActivationExamples = pack.activationExamples.filter((example) =>\n example.split(/\\s+/).some((token) => enabledRoleNames.includes(token)),\n );\n const activationExamples = (configuredActivationExamples.length\n ? configuredActivationExamples\n : enabledRoleNames.slice(0, 2).map((name) => `${name} scep dir`))\n .map((example) => `\"${example}\"`)\n .join(\" or \");\n const availableRecipes = pack.recipes.filter((recipe) => recipe.composition.some((token) => set.has(token)));\n const receiptRecipe = availableRecipes[0];\n const receiptExample = receiptRecipe\n ? `Dispatching ${receiptRecipe.composition.join(\" + \")}: ${receiptRecipe.goal}`\n : `Dispatching ${stages[0]?.name ?? \"role\"}: plain role defaults.`;\n\n // A partial roster can collapse multiple work sizes onto the same remaining chain.\n // Merge their labels rather than printing duplicate rows.\n const byChain = new Map();\n for (const r of pack.sizing) {\n const c = (r.chain ?? stages.map((s) => s.name)).filter(has);\n if (!c.length) continue;\n const key = c.join(\" → \");\n byChain.set(key, [...(byChain.get(key) ?? []), r.work]);\n }\n const rows = [...byChain].map(([c, works]) => `| ${works.join(\" or \")} | ${c} |`);\n\n const body = [\n \"---\",\n `name: ${SKILL_NAME}`,\n \"description: >-\",\n ...flow(\n `Staff a project with ${pack.label}${packSuffix(pack)}, a coordinated ${workerLabel} roster for ${pack.description.toLowerCase()} Use ` +\n `ONLY when explicitly engaged: \"staff this project\", \"use Staffed\", ${invocation}, ` +\n `or a request combining one of these exact enabled Staffed roles with behavioral modifiers or aliases: ${enabledRoleNames.join(\", \")}, or a request to launch a subagent at a named tier (fast, balanced, strong, or deep) or with a concrete model — model selection, not roster work. ` +\n `Examples: ${activationExamples}. ` +\n `${codexOrClaude ? \"Do NOT use for ordinary prompts, including edits, bug fixes, refactors, reviews or questions\" : \"Do NOT use for ordinary edits, bug fixes, refactors, reviews or questions\"} — those are ` +\n \"faster done directly.\",\n 84,\n )\n .split(\"\\n\")\n .map((l) => ` ${l}`),\n \"---\",\n \"\",\n \"# Staffed\",\n \"\",\n flow(\n \"You are the orchestrator, not a worker. Decompose the goal, dispatch the smallest sufficient \" +\n `set of personas with ${dispatchTool}, validate their output contracts, and loop back ` +\n \"only when a material failure requires it. One persona is a valid staffed pipeline.\",\n ),\n \"\",\n flow(\n \"Other subagent rosters and delegation skills may be installed alongside Staffed; while \" +\n \"Staffed is engaged it owns delegation. Dispatch only Staffed personas, treat their names \" +\n \"as authoritative when another roster defines the same one, and keep Staffed sizing, \" +\n \"effort, escalation, and artifact contracts in force instead of blending in other \" +\n \"rosters' agents, recipes, or workflow conventions.\",\n ),\n \"\",\n \"## Size the pipeline to the work\",\n \"\",\n flow(\n \"Default to one actor. Every additional stage must resolve a named uncertainty or material \" +\n \"risk that the current actor cannot own. Dispatching adds latency, cost, and a fresh context, \" +\n \"so never add a persona merely because the work can be split further.\",\n ),\n \"\",\n \"| Work | Chain |\",\n \"|---|---|\",\n ...rows,\n \"\",\n flow(\n \"Skipping stages is normal. Reach for the full pipeline only when the matter is genuinely \" +\n \"new and uncertain. Before launching more than two personas, state the planned dispatch \" +\n \"count and the specific risk or unknown each one resolves; shrink the plan if that case is weak.\",\n ),\n \"\",\n \"## Risk gates\",\n \"\",\n flow(pack.riskGate),\n \"\",\n \"## Compact by default\",\n \"\",\n flow(\n \"Ask every persona for the shortest artifact that lets the next decision or action succeed. \" +\n \"It must not restate upstream context, fill sections with speculative possibilities, or keep \" +\n \"investigating after its definition of done is met. Expand only when complexity, evidence, or \" +\n \"risk requires it. For a bounded task, prefer one compact artifact over a design document plus \" +\n \"a duplicate task document.\",\n ),\n \"\",\n \"## Effort and escalation\",\n \"\",\n flow(\n \"Every dispatch starts at effort `low` unless the user requested otherwise or approved an \" +\n \"escalation. Put `Effort: low`, `Effort: medium`, or `Effort: high` in the task. Effort controls \" +\n \"how far the persona investigates, not the care or correctness of its work. Low means the \" +\n \"shortest credible pass, not a careless one.\",\n ),\n \"\",\n flow(\n \"Before expanding, ask: can downstream act; could the remaining uncertainty materially change \" +\n \"that action; and is the next investigation likely to resolve it? Stop when the handoff is \" +\n \"dependable and more work is unlikely to change it. Do not silently raise effort.\",\n ),\n \"\",\n flow(\n \"When material uncertainty remains, the persona stops and returns an `## Escalation` naming \" +\n \"`Axis` (`effort`, `tier`, or `both`), `Requested`, `Reason`, `Expected gain`, and `Safe fallback`. \" +\n \"Approve more effort when additional investigation can resolve the issue; approve a higher \" +\n \"model tier when stronger synthesis is needed; route to another persona when the work belongs \" +\n \"elsewhere. The parent decides whether to redispatch. Never turn a completed advisory stage \" +\n \"into deeper planning or implementation without the user's approval.\",\n ),\n \"\",\n \"## Compose a role (optional)\",\n \"\",\n flow(\n \"A composition is one role plus at most one mode from each optional dimension: stance, drive, lens, audience, and voice. Default to the plain role and add a modifier only when the user requested it or it addresses a named uncertainty or risk. Honor user modifiers. Every selected modifier must earn a material change; never fill every dimension by default. Modifiers never override role scope, correctness, effort, model tier, safety, permissions, or output contracts.\",\n ),\n \"\",\n ...dimensionsFor(pack.key, catalog).flatMap((dimension) => {\n const render = (label, modes) => `${label}: ${modes.map((mode) => `\\`${mode.name}\\` (\\`${mode.alias}\\`)`).join(\", \")}`;\n if (dimension.name !== \"audience\") return [render(dimension.name, dimension.modes)];\n const packNames = new Set(pack.audiences.map((mode) => mode.name));\n return [render(\"audience (core)\", dimension.modes.filter((mode) => !packNames.has(mode.name))), render(`audience (${pack.key})`, pack.audiences)];\n }),\n \"\",\n `roles: ${stages.map((stage) => `\\`${stage.name}\\``).join(\", \")}`,\n \"\",\n flow(\n `Matching is case-insensitive but exact: accept only canonical names or listed aliases, never arbitrary prefixes. If a modifier appears, the user asks about options, or you must select a composition, read \\`references/composition.md\\` before dispatching. Otherwise do not load it. Before dispatch, state a one-line receipt such as \\`${receiptExample}\\` Repeat that exact canonical receipt in the final response so non-interactive callers retain it. A receipt is not enough: the persona task itself must include \\`Composition:\\` with canonical role and mode names plus one concise \\`Behavior:\\` line for every selected mode, copied from that mode's \\`Dispatch behavior\\` in the reference. Explicitly tell the persona that role scope, truth, correctness, safety, effort, model tier, permissions, and output contracts take precedence over every modifier.`,\n ),\n \"\",\n \"Recipes:\",\n ...availableRecipes.slice(0, 5).map((recipe) => `- ${recipe.goal} — ${recipe.composition.map((token) => `\\`${token}\\``).join(\" + \")}`),\n \"\",\n \"## The roster\",\n \"\",\n \"| Persona | Default tier | Default effort | Dispatch it for |\",\n \"|---|---|---|---|\",\n ...stages.map((s) => {\n const p = persona(s.name);\n return `| \\`${s.name}\\` | ${p?.tier ?? \"inherit\"} | ${p?.effort ?? \"low\"} | ${blurb(s.name) || s.role} |`;\n }),\n \"\",\n flow(\n \"Route by each persona's `description`, which states what it owns and what it must refuse. \" +\n \"One persona, one job. Full order when you do run end to end: \" +\n `${chain(stages)}.`,\n ),\n \"\",\n \"## Model tiers\",\n \"\",\n flow(\n \"A persona's tier names a row in `models.json`, which maps `fast`, `balanced`, `strong`, and `deep` to concrete \" +\n \"model + thinking values: the part of Staffed that works without any persona. When the user names a tier \" +\n \"(\\\"launch a deep tier subagent\\\") or an escalation approves a higher tier, run `staffed tier --compact` to \" +\n \"load this machine's four rows into context, then pass the row's model when dispatching. On pi, spell it \" +\n \"`model:thinking` when thinking is set; hosts without per-agent thinking take the model alone. Never guess a \" +\n \"model from the roster table above, which carries only tier names, and do not read a persona file for the \" +\n \"mapping: `staffed tier --compact` is the lightweight source, fresh from this machine's `models.json` and \" +\n \"reflecting profile switches and local edits. An explicit concrete-model request is also a control, not a \" +\n \"modifier: preserve the user's exact model string and pass it as the dispatch `model`, with any requested \" +\n \"Pi thinking suffix, instead of resolving or replacing it with a tier. If both a role and model are named, \" +\n \"the explicit model overrides that role's default tier for that dispatch. For a casual model request such as \" +\n \"`Opus`, `latest Sonnet`, or `Sol`, and only when the host is Pi, first try `pi --list-models ` \" +\n \"with the user's distinctive model terms; use the provider and model columns as candidates and choose an \" +\n \"exact, clearly matching ID. This lists Pi's available catalog, not necessarily the current interactive \" +\n \"session's `/scoped-models` set. If the command is unavailable, fails, returns no candidates, or the match \" +\n \"is ambiguous, continue by interpreting the request from context; do not invent an ID or block the staffed \" +\n \"dispatch. Non-Pi hosts skip the command entirely. Tier or model dispatch is model selection, not roster \" +\n \"engagement: no persona runs unless the user asked for staffed work.\",\n ),\n ];\n\n if (partial) {\n const missing = pack.stages.filter((s) => !set.has(s.name)).map((s) => s.name);\n body.push(\n \"\",\n flow(`Not installed: ${missing.join(\", \")} — cover those stages yourself or skip them.`),\n );\n }\n\n const artifactExceptions = [\n ...pack.noDirectory.filter(has).map((name) => pack.noArtifact.includes(name) ? `\\`${name}\\` writes nothing` : `\\`${name}\\`'s artifact is its assigned work itself`),\n ];\n body.push(\n \"\",\n \"## Passing work between personas\",\n \"\",\n flow(\n \"Each artifact-owning persona writes to `artifacts//index.md` and returns that path. \" +\n (codexOrClaude ? \"\" : \"For a canonical artifact dispatch, make one foreground `subagent` call with `output: false`; never set the tool's `output` path, because that path becomes authoritative and relocates the artifact under the subagent runtime. Do not revive or redispatch a completed persona merely to repair an output path. \") +\n \"Pass paths downstream, never the full document — that keeps context flat across a long \" +\n \"pipeline.\" +\n (artifactExceptions.length ? ` Exceptions: ${artifactExceptions.join(\"; \")}.` : \"\"),\n ),\n );\n\n const loops = pack.loops\n .filter((loop) => loop.requires.every(has))\n .map((loop) => `- ${loop.text}`);\n if (loops.length) body.push(\"\", \"## Loops\", \"\", ...loops);\n\n if (!codexOrClaude) {\n const parallel = pack.parallelism\n .filter((item) => item.requires.every(has))\n .map((item) => item.text);\n if (parallel.length) body.push(\"\", \"## Parallelism\", \"\", flow(parallel.join(\" \")));\n }\n body.push(\"\");\n return body.join(\"\\n\");\n}\n\nexport function generateCompositionReference({ pack: packName = DEFAULT_PACK, personas = [], catalog } = {}) {\n const pack = resolvePack(packName, catalog);\n const roster = personas.length ? personas : pack.personas;\n const lines = [\n \"# Staffed composition reference\", \"\",\n `Active staff pack: **${pack.label}**${pack.experimental ? \" — experimental preview\" : \"\"}.`, \"\",\n \"A dimension is a configurable axis; a mode is an available value; a selected mode is a modifier; one role plus modifiers is a composition. Select at most one mode per dimension. Controls such as effort, model tier, permissions, safety, and output contracts are never modifiers and always take precedence.\", \"\",\n \"Use modifiers sparsely. Preserve explicit user modifiers, explain what agent-selected modifiers earn, and default to the plain role.\", \"\",\n ];\n for (const dimension of dimensionsFor(pack.key, catalog)) {\n lines.push(`## ${dimension.name}`, \"\", dimension.question, \"\");\n const packNames = new Set(pack.audiences.map((mode) => mode.name));\n for (const mode of dimension.modes) {\n if (dimension.name === \"audience\" && mode === dimension.modes[0]) lines.push(\"### Core audiences\", \"\");\n if (dimension.name === \"audience\" && packNames.has(mode.name) && !packNames.has(dimension.modes[dimension.modes.indexOf(mode) - 1]?.name)) lines.push(`### ${pack.label} audiences`, \"\");\n const heading = dimension.name === \"audience\" ? \"####\" : \"###\";\n lines.push(`${heading} ${mode.name} (\\`${mode.alias}\\`)`, \"\", mode.summary, \"\", `Dispatch behavior: ${mode.phrase}.`, \"\", `Useful for: ${mode.usefulFor}.`, \"\", `Watch for: ${mode.shadow}.`, \"\");\n }\n }\n lines.push(\"## Roles\", \"\");\n for (const persona of roster) lines.push(`### ${persona.name}`, \"\", persona.meta.description, \"\");\n lines.push(\"## Recipes\", \"\");\n const roleNames = new Set(roster.map((persona) => persona.name));\n for (const recipe of pack.recipes.filter((item) => item.composition.some((token) => roleNames.has(token)))) lines.push(`### ${recipe.name}`, \"\", recipe.goal, \"\", recipe.composition.map((token) => `\\`${token}\\``).join(\" + \"), \"\");\n lines.push(\"## Composition rules\", \"\", \"- Matching is case-insensitive exact-token matching against canonical names and declared aliases.\", \"- One role is required; one mode maximum per optional dimension.\", \"- A modifier changes approach, not authority, truth, correctness, or scope.\", \"- Give a one-line canonical composition receipt before dispatch and repeat it in the final response.\", \"- Put the canonical composition and every selected mode's Dispatch behavior in the persona task; role, safety, controls, and output contracts always take precedence.\", \"\");\n return lines.join(\"\\n\");\n}\n\nexport const generate = (enabled, personas = []) => generateSkill({ hostKey: \"pi\", enabled, personas });\nexport const skillPath = (dir) => join(dir, SKILL_NAME, \"SKILL.md\");\nexport const compositionReferencePath = (dir) => join(dir, SKILL_NAME, \"references\", \"composition.md\");\n"}},"text.mjs":{"file":{"contents":"// Shared plain-text rendering: word wrapping and fixed-width column tables.\n\n/** Wrap to ~width columns, counting an optional indent prefix toward the width. */\nexport function wrap(text, width = 86, indent = \"\") {\n const out = [];\n let line = \"\";\n for (const word of String(text).split(/\\s+/)) {\n if (line && `${indent}${line} ${word}`.length > width) {\n out.push(indent + line);\n line = word;\n } else line = line ? `${line} ${word}` : word;\n }\n if (line) out.push(indent + line);\n return out.join(\"\\n\");\n}\n\nconst pad = (rows, i) => Math.max(...rows.map((r) => String(r[i]).length));\n\n/** Render rows as columns padded to each column's widest cell. */\nexport function table(rows) {\n const widths = rows[0].map((_, i) => pad(rows, i));\n return rows\n .map((row) => row.map((cell, i) => String(cell).padEnd(widths[i])).join(\" \").trimEnd())\n .join(\"\\n\");\n}\n"}}}}}}}},".claude":{"directory":{"README.md":{"file":{"contents":"An empty Claude Code configuration folder, so `staffed enable` detects Claude Code and installs into ~/.claude.\nNo agent runs in this demo.\n"}}}},"bin":{"directory":{"staffed":{"file":{"contents":"#!/usr/bin/env node\n// CommonJS on purpose: extensionless ES modules do not run in the sandbox.\nimport(\"../node_modules/staffed/bin/staffed.mjs\");\n"}}}}}