@unbrained/pm-cli 2026.7.6 → 2026.7.8

package/dist/cli-bundle/chunks/chunk-MFSCBT5Q.js

@@ -1,995 +0,0 @@
-
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="60eff3e2-3dae-547d-af75-15d1de75a9b5")}catch(e){}}();
-import {
-  runExtension
-} from "./chunk-WG34ZNQQ.js";
-import {
-  TYPE_PRESET_NAMES,
-  normalizeTypePresetName,
-  resolveTypePresetDefinitions
-} from "./chunk-XB7KFVFI.js";
-import {
-  normalizePrefix
-} from "./chunk-G24G7ZAV.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  readSettings,
-  runActiveOnWriteHooks,
-  writeSettings
-} from "./chunk-E3SZTQ4K.js";
-import {
-  parseItemTypesFile,
-  serializeItemTypesFile,
-  upsertItemType
-} from "./chunk-KUOOJR35.js";
-import {
-  DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
-  EXIT_CODE,
-  GOVERNANCE_PRESET_DEFAULTS,
-  PM_REQUIRED_SUBDIRS,
-  SETTINGS_DEFAULTS,
-  ensureRuntimeSchemaFileScaffold,
-  filePathForSchemaSection,
-  normalizeRuntimeSchemaSettings,
-  pathExists,
-  readFileIfExists,
-  resolveItemTypeRegistry,
-  resolvePmRoot,
-  writeFileAtomic
-} from "./chunk-57NWPFF2.js";
-
-// dist/cli/commands/init.js
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
-import readline2 from "node:readline/promises";
-import { stdin as input2, stdout as output2 } from "node:process";
-
-// dist/cli/commands/init-agent-guidance.js
-import fs from "node:fs/promises";
-import path from "node:path";
-import readline from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-var INIT_AGENT_GUIDANCE_MODE_VALUES = ["ask", "add", "skip", "status"];
-var AGENT_GUIDANCE_TARGET_FILENAMES = ["AGENTS.md", "CLAUDE.md"];
-var AGENT_GUIDANCE_REQUIRED_TOKENS = [
-  "pm init",
-  "pm context",
-  "pm search",
-  "pm create",
-  "pm claim",
-  "pm files",
-  "pm docs",
-  "pm test --run",
-  "pm close",
-  "pm release",
-  "pm_author"
-];
-var AGENT_GUIDANCE_REQUIRED_TOKEN_THRESHOLD = 8;
-var AGENT_GUIDANCE_TEMPLATE_VERSION = 1;
-var AGENT_GUIDANCE_START_MARKER_PREFIX = "<!-- pm-cli:agent-guidance:start:";
-var AGENT_GUIDANCE_START_MARKER = `<!-- pm-cli:agent-guidance:start:v${AGENT_GUIDANCE_TEMPLATE_VERSION} -->`;
-var AGENT_GUIDANCE_END_MARKER = "<!-- pm-cli:agent-guidance:end -->";
-var AGENT_GUIDANCE_ADD_LATER_HINT = "Add workflow guidance later: pm init --agent-guidance add";
-var createAgentGuidanceReadlineInterface = () => readline.createInterface({ input, output });
-function toPortableRelativePath(projectRoot, targetPath) {
-  const relative = path.relative(projectRoot, targetPath);
-  if (relative.length === 0) {
-    return path.basename(targetPath);
-  }
-  return relative.split(path.sep).join("/");
-}
-function ensureTrailingNewline(value) {
-  return value.endsWith("\n") ? value : `${value}
-`;
-}
-function detectLineEnding(value) {
-  return value.includes("\r\n") ? "\r\n" : "\n";
-}
-function findGuidanceBlockRange(content) {
-  const startIndex = content.indexOf(AGENT_GUIDANCE_START_MARKER_PREFIX);
-  if (startIndex === -1) {
-    return null;
-  }
-  const endMarkerIndex = content.indexOf(AGENT_GUIDANCE_END_MARKER, startIndex);
-  if (endMarkerIndex === -1) {
-    return null;
-  }
-  return {
-    start_index: startIndex,
-    end_index: endMarkerIndex + AGENT_GUIDANCE_END_MARKER.length
-  };
-}
-function hasGuidanceMarker(content) {
-  return findGuidanceBlockRange(content) !== null;
-}
-function buildAgentGuidanceBlock(lineEnding) {
-  const lines = [
-    AGENT_GUIDANCE_START_MARKER,
-    "## pm Workflow (Agent Quickstart)",
-    "",
-    '- Orient before mutate: `pm context --limit 10`, `pm search "<keywords>" --limit 10`, `pm list-open --limit 20`.',
-    "- Claim and execute: `pm claim <id>` then `pm update <id> --status in_progress`.",
-    '- Link evidence while coding: `pm files <id> --add ...`, `pm docs <id> --add ...`, `pm test <id> --add command="node scripts/run-tests.mjs test -- ..."`.',
-    '- Verify and close: `pm test <id> --run --progress`, `pm close <id> "<evidence>" --validate-close warn`, `pm release <id>`.',
-    "- Set `PM_AUTHOR=<stable-agent-id>` before mutation commands.",
-    "",
-    AGENT_GUIDANCE_END_MARKER,
-    ""
-  ];
-  return lines.join(lineEnding);
-}
-function upsertAgentGuidanceBlock(existingContent) {
-  const lineEnding = detectLineEnding(existingContent);
-  const nextBlock = buildAgentGuidanceBlock(lineEnding);
-  const existingRange = findGuidanceBlockRange(existingContent);
-  if (existingRange) {
-    const trailingContent = existingContent.slice(existingRange.end_index);
-    const normalizedTrailingContent = trailingContent.startsWith("\r\n") ? trailingContent.slice(2) : trailingContent.startsWith("\n") ? trailingContent.slice(1) : trailingContent;
-    const nextContent2 = ensureTrailingNewline(`${existingContent.slice(0, existingRange.start_index)}${nextBlock}${normalizedTrailingContent}`);
-    return {
-      next_content: nextContent2,
-      changed: nextContent2 !== existingContent
-    };
-  }
-  const separator = existingContent.length === 0 ? "" : existingContent.endsWith("\n") ? "\n" : "\n\n";
-  const nextContent = ensureTrailingNewline(`${existingContent}${separator}${nextBlock}`);
-  return {
-    next_content: nextContent,
-    changed: nextContent !== existingContent
-  };
-}
-function resolveProjectRoot(pmRoot, cwd) {
-  const parent = path.dirname(pmRoot);
-  if (path.basename(pmRoot) === "pm" && path.basename(parent) === ".agents") {
-    return path.dirname(parent);
-  }
-  return path.resolve(cwd, pmRoot);
-}
-function resolveTargetGuidancePath(scans, projectRoot) {
-  const existingAgents = scans.find((entry) => path.basename(entry.file_path) === "AGENTS.md" && entry.exists);
-  if (existingAgents) {
-    return existingAgents.file_path;
-  }
-  const existingAny = scans.find((entry) => entry.exists);
-  if (existingAny) {
-    return existingAny.file_path;
-  }
-  return path.join(projectRoot, "AGENTS.md");
-}
-function parsePromptChoice(answer, currentDefault) {
-  const normalized = answer.trim().toLowerCase();
-  if (normalized.length === 0) {
-    return currentDefault;
-  }
-  if (normalized === "y" || normalized === "yes") {
-    return true;
-  }
-  if (normalized === "n" || normalized === "no") {
-    return false;
-  }
-  return currentDefault;
-}
-async function promptForGuidanceWrite(targetRelativePath) {
-  const rl = createAgentGuidanceReadlineInterface();
-  try {
-    output.write("\nAgent guidance check\n");
-    output.write("No AGENTS.md/CLAUDE.md file currently contains compact pm workflow guidance.\n");
-    const answer = await rl.question(`Add a compact pm workflow section to ${targetRelativePath}? [Y/n] `);
-    output.write("\n");
-    return parsePromptChoice(answer, true);
-  } finally {
-    rl.close();
-  }
-}
-function normalizeAgentGuidanceState(settings) {
-  const current = settings.agent_guidance;
-  return {
-    prompt_completed: current?.prompt_completed === true,
-    declined: current?.declined === true,
-    declined_at: typeof current?.declined_at === "string" ? current.declined_at : "",
-    template_version: typeof current?.template_version === "number" && Number.isInteger(current.template_version) && current.template_version > 0 ? current.template_version : AGENT_GUIDANCE_TEMPLATE_VERSION,
-    last_checked_files: Array.isArray(current?.last_checked_files) ? [...new Set(current.last_checked_files.map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right)) : []
-  };
-}
-async function scanGuidanceFiles(projectRoot) {
-  const scans = [];
-  for (const filename of AGENT_GUIDANCE_TARGET_FILENAMES) {
-    const filePath = path.join(projectRoot, filename);
-    const exists = await pathExists(filePath);
-    if (!exists) {
-      scans.push({
-        file_path: filePath,
-        exists,
-        has_guidance: false,
-        has_marker: false
-      });
-      continue;
-    }
-    const content = await fs.readFile(filePath, "utf8");
-    const contentLower = content.toLowerCase();
-    const tokenHits = AGENT_GUIDANCE_REQUIRED_TOKENS.filter((token) => contentLower.includes(token));
-    const hasMarker = hasGuidanceMarker(content);
-    scans.push({
-      file_path: filePath,
-      exists,
-      has_guidance: hasMarker || tokenHits.length >= AGENT_GUIDANCE_REQUIRED_TOKEN_THRESHOLD,
-      has_marker: hasMarker
-    });
-  }
-  return scans;
-}
-function pushUnique(target, value) {
-  if (!target.includes(value)) {
-    target.push(value);
-  }
-}
-function applyAgentGuidanceState(settings, currentState) {
-  const existing = normalizeAgentGuidanceState(settings);
-  const changed = JSON.stringify(existing) !== JSON.stringify(currentState);
-  if (changed) {
-    settings.agent_guidance = currentState;
-  }
-  return { changed, state: currentState };
-}
-async function writeGuidanceFile(filePath) {
-  const exists = await pathExists(filePath);
-  const currentContent = exists ? await fs.readFile(filePath, "utf8") : "";
-  const nextContent = upsertAgentGuidanceBlock(currentContent);
-  if (!nextContent.changed) {
-    return { changed: false, warnings: [] };
-  }
-  await fs.writeFile(filePath, nextContent.next_content, "utf8");
-  return {
-    changed: true,
-    warnings: await runActiveOnWriteHooks({
-      path: filePath,
-      scope: "project",
-      op: "init:agent_guidance_file"
-    })
-  };
-}
-function buildInitAgentGuidanceSummary(params) {
-  return {
-    mode: params.mode,
-    present: params.scans.some((entry) => entry.has_guidance),
-    prompted: params.prompted,
-    applied: params.applied,
-    skipped: params.skipped,
-    declined: params.state.declined,
-    prompt_completed: params.state.prompt_completed,
-    template_version: params.state.template_version,
-    target_file: params.targetRelativePath,
-    checked_files: params.scans.map((entry) => toPortableRelativePath(params.projectRoot, entry.file_path)),
-    files_with_guidance: params.scans.filter((entry) => entry.has_guidance).map((entry) => toPortableRelativePath(params.projectRoot, entry.file_path)),
-    missing_files: params.scans.filter((entry) => !entry.exists).map((entry) => toPortableRelativePath(params.projectRoot, entry.file_path))
-  };
-}
-async function refreshGuidanceScansAfterApply(applied, scans, projectRoot) {
-  return applied ? await scanGuidanceFiles(projectRoot) : scans;
-}
-function markAgentGuidanceRunState(flow, checkedFiles, partial) {
-  flow.state = {
-    ...flow.state,
-    ...partial,
-    template_version: AGENT_GUIDANCE_TEMPLATE_VERSION,
-    last_checked_files: checkedFiles
-  };
-}
-async function addAgentGuidanceBlockIfMissing(flow, context) {
-  if (context.presentBefore) {
-    return;
-  }
-  const writeResult = await writeGuidanceFile(context.targetPath);
-  flow.warnings.push(...writeResult.warnings);
-  if (writeResult.changed) {
-    flow.applied = true;
-    flow.warnings.push(`agent_guidance:added:${context.targetRelativePath}`);
-  }
-}
-function handleAgentGuidanceStatusMode(flow, presentBefore) {
-  if (!presentBefore) {
-    flow.warnings.push("agent_guidance:missing");
-    pushUnique(flow.nextSteps, AGENT_GUIDANCE_ADD_LATER_HINT);
-  }
-}
-function handleAgentGuidanceSkipMode(flow, checkedFiles) {
-  flow.skipped = true;
-  markAgentGuidanceRunState(flow, checkedFiles, {
-    prompt_completed: true,
-    declined: true,
-    declined_at: flow.state.declined_at || (/* @__PURE__ */ new Date()).toISOString()
-  });
-  flow.warnings.push("agent_guidance:explicit_skip");
-  pushUnique(flow.nextSteps, AGENT_GUIDANCE_ADD_LATER_HINT);
-}
-async function handleAgentGuidanceAddMode(flow, context) {
-  await addAgentGuidanceBlockIfMissing(flow, context);
-  markAgentGuidanceRunState(flow, context.checkedFiles, {
-    prompt_completed: true,
-    declined: false,
-    declined_at: ""
-  });
-}
-function handlePresentAgentGuidance(flow, checkedFiles) {
-  if (flow.state.declined) {
-    markAgentGuidanceRunState(flow, checkedFiles, {
-      prompt_completed: true,
-      declined: false,
-      declined_at: ""
-    });
-  }
-}
-function handleDeclinedAgentGuidance(flow) {
-  flow.skipped = true;
-  flow.warnings.push("agent_guidance:skipped_declined");
-  pushUnique(flow.nextSteps, AGENT_GUIDANCE_ADD_LATER_HINT);
-}
-async function handleInteractiveAgentGuidancePrompt(flow, context) {
-  flow.prompted = true;
-  const approved = await promptForGuidanceWrite(context.targetRelativePath);
-  if (approved) {
-    await addAgentGuidanceBlockIfMissing(flow, context);
-    markAgentGuidanceRunState(flow, context.checkedFiles, {
-      prompt_completed: true,
-      declined: false,
-      declined_at: ""
-    });
-    return;
-  }
-  flow.skipped = true;
-  markAgentGuidanceRunState(flow, context.checkedFiles, {
-    prompt_completed: true,
-    declined: true,
-    declined_at: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  flow.warnings.push("agent_guidance:declined");
-  pushUnique(flow.nextSteps, AGENT_GUIDANCE_ADD_LATER_HINT);
-}
-function handleNonInteractiveMissingAgentGuidance(flow) {
-  flow.warnings.push("agent_guidance:missing_non_interactive");
-  pushUnique(flow.nextSteps, AGENT_GUIDANCE_ADD_LATER_HINT);
-}
-async function applyAgentGuidanceMode(initialState, context) {
-  const flow = {
-    warnings: [],
-    nextSteps: [],
-    prompted: false,
-    applied: false,
-    skipped: false,
-    state: initialState
-  };
-  if (context.mode === "status") {
-    handleAgentGuidanceStatusMode(flow, context.presentBefore);
-    return flow;
-  }
-  if (context.mode === "skip") {
-    handleAgentGuidanceSkipMode(flow, context.checkedFiles);
-    return flow;
-  }
-  if (context.mode === "add") {
-    await handleAgentGuidanceAddMode(flow, context);
-    return flow;
-  }
-  if (context.presentBefore) {
-    handlePresentAgentGuidance(flow, context.checkedFiles);
-    return flow;
-  }
-  if (flow.state.prompt_completed && flow.state.declined) {
-    handleDeclinedAgentGuidance(flow);
-    return flow;
-  }
-  if (context.interactive) {
-    await handleInteractiveAgentGuidancePrompt(flow, context);
-    return flow;
-  }
-  handleNonInteractiveMissingAgentGuidance(flow);
-  return flow;
-}
-async function runInitAgentGuidance(options) {
-  const projectRoot = resolveProjectRoot(options.pm_root, options.cwd);
-  let scans = await scanGuidanceFiles(projectRoot);
-  const targetPath = resolveTargetGuidancePath(scans, projectRoot);
-  const targetRelativePath = toPortableRelativePath(projectRoot, targetPath);
-  const checkedFiles = scans.map((entry) => toPortableRelativePath(projectRoot, entry.file_path));
-  const presentBefore = scans.some((entry) => entry.has_guidance);
-  const flow = await applyAgentGuidanceMode(normalizeAgentGuidanceState(options.settings), {
-    mode: options.mode,
-    interactive: options.interactive,
-    targetPath,
-    targetRelativePath,
-    checkedFiles,
-    presentBefore
-  });
-  const stateUpdate = applyAgentGuidanceState(options.settings, flow.state);
-  scans = await refreshGuidanceScansAfterApply(flow.applied, scans, projectRoot);
-  const summary = buildInitAgentGuidanceSummary({
-    mode: options.mode,
-    scans,
-    projectRoot,
-    targetRelativePath,
-    prompted: flow.prompted,
-    applied: flow.applied,
-    skipped: flow.skipped,
-    state: flow.state
-  });
-  return {
-    summary,
-    warnings: flow.warnings,
-    next_steps: flow.nextSteps,
-    settings_changed: stateUpdate.changed
-  };
-}
-
-// dist/cli/commands/init.js
-function summarizeInitResult(result) {
-  return {
-    ok: result.ok,
-    path: result.path,
-    id_prefix: result.settings.id_prefix,
-    governance_preset: result.governance_preset,
-    telemetry: {
-      enabled: result.settings.telemetry.enabled,
-      capture_level: result.settings.telemetry.capture_level
-    },
-    output_format: result.settings.output.default_format,
-    created_dirs_count: result.created_dirs.length,
-    created_dirs: result.created_dirs,
-    warnings: result.warnings,
-    wizard_used: result.wizard_used,
-    ...result.registered_type_preset ? { registered_type_preset: result.registered_type_preset } : {},
-    ...result.installed_packages ? { installed_packages: result.installed_packages } : {},
-    next_steps: result.next_steps,
-    agent_guidance: result.agent_guidance,
-    hint: "Re-run with --verbose for the full settings tree."
-  };
-}
-var _testOnly = {
-  normalizeInitGovernancePreset,
-  normalizeInitTypePreset,
-  normalizeOptionalInitAuthor,
-  normalizeInitAgentGuidanceMode,
-  isPathLikeInitTarget,
-  resolveInitInvocation,
-  parseYesNoChoice,
-  applyGovernancePreset,
-  runInitWizard,
-  setInitReadlineFactoryForTests,
-  summarizeInstalledPackages,
-  registerInitTypePreset,
-  assertExplicitTrackerPathIsNotWorkspaceRoot,
-  isLikelyWorkspaceRoot
-};
-var createInitReadlineInterface = () => readline2.createInterface({ input: input2, output: output2 });
-function setInitReadlineFactoryForTests(factory) {
-  createInitReadlineInterface = factory ?? (() => readline2.createInterface({ input: input2, output: output2 }));
-}
-function cloneDefaults() {
-  return structuredClone(SETTINGS_DEFAULTS);
-}
-var BUILTIN_GOVERNANCE_PRESETS = ["minimal", "default", "strict"];
-function normalizeInitGovernancePreset(rawValue) {
-  if (rawValue === void 0) {
-    return void 0;
-  }
-  const normalized = rawValue.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized.length === 0) {
-    throw new PmCliError("--preset must not be empty", EXIT_CODE.USAGE);
-  }
-  if (normalized === "minimal" || normalized === "default" || normalized === "strict") {
-    return normalized;
-  }
-  if (normalized === "lite" || normalized === "minimum") {
-    return "minimal";
-  }
-  throw new PmCliError(`Invalid --preset value "${rawValue}". Allowed: ${BUILTIN_GOVERNANCE_PRESETS.join(", ")}`, EXIT_CODE.USAGE);
-}
-function normalizeInitTypePreset(rawValue) {
-  if (rawValue === void 0) {
-    return void 0;
-  }
-  if (rawValue.trim().length === 0) {
-    throw new PmCliError("--type-preset must not be empty", EXIT_CODE.USAGE);
-  }
-  try {
-    return normalizeTypePresetName(rawValue);
-  } catch {
-    throw new PmCliError(`Invalid --type-preset value "${rawValue}". Allowed: ${TYPE_PRESET_NAMES.join(", ")}`, EXIT_CODE.USAGE);
-  }
-}
-function normalizeOptionalInitAuthor(rawValue) {
-  if (rawValue === void 0) {
-    return void 0;
-  }
-  const normalized = rawValue.trim();
-  if (normalized.length === 0) {
-    throw new PmCliError("--author must not be empty", EXIT_CODE.USAGE);
-  }
-  return normalized;
-}
-function isPathLikeInitTarget(rawValue) {
-  if (rawValue === void 0) {
-    return false;
-  }
-  const trimmed = rawValue.trim();
-  if (trimmed.length === 0) {
-    return false;
-  }
-  return path2.isAbsolute(trimmed) || trimmed.startsWith(".") || trimmed.includes("/") || trimmed.includes("\\");
-}
-function resolveInitInvocation(cwd, global, prefixArg) {
-  if (global.path === void 0 && isPathLikeInitTarget(prefixArg)) {
-    const positionalTarget = path2.resolve(cwd, prefixArg.trim());
-    return {
-      pmRoot: positionalTarget,
-      prefixArg: void 0,
-      positional_target: positionalTarget
-    };
-  }
-  return {
-    pmRoot: resolvePmRoot(cwd, global.path),
-    prefixArg
-  };
-}
-function normalizeInitAgentGuidanceMode(rawValue) {
-  if (rawValue === void 0) {
-    return "ask";
-  }
-  const normalized = rawValue.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized.length === 0) {
-    throw new PmCliError("--agent-guidance must not be empty", EXIT_CODE.USAGE);
-  }
-  if (normalized === "ask" || normalized === "add" || normalized === "skip" || normalized === "status") {
-    return normalized;
-  }
-  throw new PmCliError(`Invalid --agent-guidance value "${rawValue}". Allowed: ${INIT_AGENT_GUIDANCE_MODE_VALUES.join(", ")}`, EXIT_CODE.USAGE);
-}
-function parseYesNoChoice(answer, currentDefault) {
-  const normalized = answer.trim().toLowerCase();
-  if (normalized.length === 0) {
-    return currentDefault;
-  }
-  if (normalized === "y" || normalized === "yes") {
-    return true;
-  }
-  if (normalized === "n" || normalized === "no") {
-    return false;
-  }
-  return currentDefault;
-}
-function applyGovernancePreset(settings, preset) {
-  const knobs = GOVERNANCE_PRESET_DEFAULTS[preset];
-  settings.governance = {
-    preset,
-    ...knobs
-  };
-  settings.validation.parent_reference = knobs.parent_reference;
-  settings.validation.metadata_profile = knobs.metadata_profile;
-}
-function isInstalledPackageEntry(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function summarizeInstalledPackages(result) {
-  const details = result.details;
-  return {
-    installed_all: details.installed_all === true,
-    installed_count: typeof details.installed_count === "number" ? details.installed_count : 0,
-    packages: Array.isArray(details.packages) ? details.packages.filter(isInstalledPackageEntry).map((entry) => ({
-      alias: typeof entry.alias === "string" ? entry.alias : "",
-      ok: entry.ok === true
-    })) : []
-  };
-}
-async function registerInitTypePreset(pmRoot, settings, preset) {
-  const schema = normalizeRuntimeSchemaSettings(settings.schema);
-  const typesPath = filePathForSchemaSection(pmRoot, schema.files.types, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.types);
-  const parsed = parseItemTypesFile(await readFileIfExists(typesPath));
-  let nextFile = parsed;
-  const registered = [];
-  const updated = [];
-  for (const normalized of resolveTypePresetDefinitions(preset)) {
-    const upsert = upsertItemType(nextFile, normalized);
-    nextFile = upsert.file;
-    (upsert.replaced ? updated : registered).push(upsert.definition.name);
-  }
-  await writeFileAtomic(typesPath, serializeItemTypesFile(nextFile));
-  return {
-    name: preset,
-    registered,
-    updated,
-    file: typesPath
-  };
-}
-async function isLikelyWorkspaceRoot(candidate) {
-  const indicators = [
-    ".git",
-    "package.json",
-    "pnpm-workspace.yaml",
-    "AGENTS.md",
-    path2.join(".agents", "pm")
-  ];
-  for (const indicator of indicators) {
-    if (await pathExists(path2.join(candidate, indicator))) {
-      return true;
-    }
-  }
-  return false;
-}
-async function assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, global, force) {
-  if (global.path === void 0 || force) {
-    return;
-  }
-  if (await pathExists(path2.join(pmRoot, "settings.json"))) {
-    return;
-  }
-  if (!await isLikelyWorkspaceRoot(pmRoot)) {
-    return;
-  }
-  const nestedTracker = path2.join(pmRoot, ".agents", "pm");
-  throw new PmCliError(`Refusing to initialize tracker files directly in workspace root "${pmRoot}".`, EXIT_CODE.USAGE, {
-    code: "workspace_root_pm_path",
-    type: "urn:pm-cli:error:workspace_root_pm_path",
-    why: "--pm-path/--path points at the tracker storage directory itself, not the repository workspace. Point it at .agents/pm or pass --force if you intentionally want root-level tracker files.",
-    examples: [
-      `pm --pm-path ${nestedTracker} init --yes`,
-      "pm init --yes",
-      `pm --pm-path ${pmRoot} init --yes --force`
-    ],
-    nextSteps: [
-      "Use --pm-path <repo>/.agents/pm for repository-local tracker storage.",
-      "Use PM_PATH only for sandboxed tests or explicit tracker roots.",
-      "Pass --force only when root-level tracker files are intentional."
-    ],
-    recovery: {
-      next_best_command: `pm --pm-path ${nestedTracker} init --yes`
-    }
-  });
-}
-async function ensureInitDirectories(pmRoot, subdirs) {
-  const createdDirs = [];
-  const warnings = [];
-  for (const subdir of subdirs) {
-    const target = subdir ? path2.join(pmRoot, subdir) : pmRoot;
-    const existed = await pathExists(target);
-    await fs2.mkdir(target, { recursive: true });
-    if (existed) {
-      warnings.push(`already_exists:${target}`);
-    } else {
-      createdDirs.push(target);
-    }
-    warnings.push(...await runActiveOnWriteHooks({
-      path: target,
-      scope: "project",
-      op: "init:ensure_dir"
-    }));
-  }
-  return { createdDirs, warnings };
-}
-async function runInitWizard(initialPrefix, telemetryDefault) {
-  const rl = createInitReadlineInterface();
-  try {
-    output2.write("pm init setup wizard (agent-optimized)\n");
-    output2.write("This walkthrough is non-destructive and each choice can be changed later with pm config.\n\n");
-    output2.write("1/3 Item ID prefix\n");
-    output2.write("Prefix is prepended to generated IDs (for example pm-a1b2).\n");
-    const prefixAnswer = await rl.question(`Item ID prefix [${initialPrefix}]: `);
-    const resolvedPrefix = prefixAnswer.trim().length > 0 ? normalizePrefix(prefixAnswer) : initialPrefix;
-    output2.write("\n2/3 Governance preset\n");
-    output2.write("minimal: no ownership blocking, progressive create defaults, close validation off.\n");
-    output2.write("default: ownership conflict warnings, progressive create defaults, close validation warn.\n");
-    output2.write("strict: ownership blocking, strict create defaults, close validation strict.\n");
-    const presetAnswer = await rl.question("Governance preset [minimal/default/strict] (default: minimal): ");
-    const presetChoice = presetAnswer.trim().length > 0 ? presetAnswer.trim() : "minimal";
-    let resolvedPreset = "minimal";
-    try {
-      resolvedPreset = normalizeInitGovernancePreset(presetChoice);
-    } catch {
-      output2.write(`Unrecognized governance preset "${presetChoice}"; using minimal.
-`);
-    }
-    output2.write("\n3/3 Project telemetry\n");
-    output2.write("Telemetry helps improve reliability and can be disabled anytime via pm config.\n");
-    const telemetryLabel = telemetryDefault ? "Y/n" : "y/N";
-    const telemetryAnswer = await rl.question(`Enable telemetry for this project? [${telemetryLabel}] `);
-    const telemetryEnabled = parseYesNoChoice(telemetryAnswer, telemetryDefault);
-    output2.write("\n");
-    return {
-      prefix: resolvedPrefix,
-      preset: resolvedPreset,
-      telemetry_enabled: telemetryEnabled
-    };
-  } finally {
-    rl.close();
-  }
-}
-function normalizeInitCommandOptions(options) {
-  return {
-    presetFromOption: normalizeInitGovernancePreset(options.preset),
-    useDefaults: options.defaults === true,
-    authorFromOption: normalizeOptionalInitAuthor(options.author),
-    installBundledPackages: options.withPackages === true,
-    agentGuidanceMode: normalizeInitAgentGuidanceMode(options.agentGuidance),
-    typePreset: normalizeInitTypePreset(options.typePreset)
-  };
-}
-function collectExistingSettingsPendingChanges(params) {
-  const pendingChanges = [];
-  if (params.prefixArg !== void 0 && params.settings.id_prefix !== params.normalizedPrefix) {
-    pendingChanges.push("id_prefix");
-  }
-  if (params.presetFromOption !== void 0 && params.settings.governance.preset !== params.presetFromOption) {
-    pendingChanges.push("governance_preset");
-  }
-  if (params.authorFromOption !== void 0 && params.settings.author_default !== params.authorFromOption) {
-    pendingChanges.push("author_default");
-  }
-  return pendingChanges;
-}
-function assertExistingSettingsUpdateAllowed(settingsPath, pendingChanges, force) {
-  if (pendingChanges.length === 0 || force) {
-    return;
-  }
-  throw new PmCliError(`Refusing to update existing tracker settings at ${settingsPath} without --force.`, EXIT_CODE.USAGE, {
-    code: "init_existing_settings_requires_force",
-    type: "urn:pm-cli:error:init_existing_settings_requires_force",
-    required: `--force for ${pendingChanges.join(", ")}`,
-    why: "pm init is safe to rerun, but changing id prefix, governance preset, or default author on an existing tracker can corrupt long-lived project context when an agent meant to initialize a sandbox path.",
-    examples: [
-      "pm init --yes",
-      "pm init ./sandbox-pm --yes",
-      "pm init acme --yes --force"
-    ],
-    nextSteps: [
-      "If you meant to initialize a sandbox tracker, pass a path-like positional such as ./sandbox-pm or /tmp/pm-test.",
-      "If you intentionally want to rewrite this existing tracker's init-managed settings, rerun with --force."
-    ]
-  });
-}
-function applyExistingSettingsUpdates(params) {
-  let changed = false;
-  if (params.prefixArg !== void 0 && params.settings.id_prefix !== params.normalizedPrefix) {
-    params.settings.id_prefix = params.normalizedPrefix;
-    params.warnings.push(`updated:id_prefix:${params.normalizedPrefix}`);
-    changed = true;
-  }
-  if (params.presetFromOption !== void 0 && params.settings.governance.preset !== params.presetFromOption) {
-    applyGovernancePreset(params.settings, params.presetFromOption);
-    params.warnings.push(`updated:governance_preset:${params.presetFromOption}`);
-    changed = true;
-  }
-  if (params.authorFromOption !== void 0 && params.settings.author_default !== params.authorFromOption) {
-    params.settings.author_default = params.authorFromOption;
-    params.warnings.push(`updated:author_default:${params.authorFromOption}`);
-    changed = true;
-  }
-  return changed;
-}
-async function loadExistingInitSettings(params) {
-  const settings = await readSettings(params.pmRoot);
-  params.warnings.push(`already_exists:${params.settingsPath}`);
-  const pendingChanges = collectExistingSettingsPendingChanges({
-    settings,
-    normalizedPrefix: params.normalizedPrefix,
-    prefixArg: params.prefixArg,
-    presetFromOption: params.normalizedOptions.presetFromOption,
-    authorFromOption: params.normalizedOptions.authorFromOption
-  });
-  assertExistingSettingsUpdateAllowed(params.settingsPath, pendingChanges, params.options.force === true);
-  if (applyExistingSettingsUpdates({
-    settings,
-    normalizedPrefix: params.normalizedPrefix,
-    prefixArg: params.prefixArg,
-    presetFromOption: params.normalizedOptions.presetFromOption,
-    authorFromOption: params.normalizedOptions.authorFromOption,
-    warnings: params.warnings
-  })) {
-    await writeSettings(params.pmRoot, settings);
-  }
-  return {
-    settings,
-    normalizedPrefix: params.normalizedPrefix,
-    chosenPreset: params.normalizedOptions.presetFromOption,
-    wizardUsed: false
-  };
-}
-async function createNewInitSettings(params) {
-  let normalizedPrefix = params.normalizedPrefix;
-  let chosenPreset = params.normalizedOptions.presetFromOption;
-  let chosenTelemetryEnabled;
-  let wizardUsed = false;
-  if (params.normalizedOptions.presetFromOption === void 0 && !params.normalizedOptions.useDefaults && process.stdin.isTTY === true && process.stdout.isTTY === true) {
-    const wizardChoices = await runInitWizard(normalizedPrefix, SETTINGS_DEFAULTS.telemetry.enabled);
-    normalizedPrefix = wizardChoices.prefix;
-    chosenPreset = wizardChoices.preset;
-    chosenTelemetryEnabled = wizardChoices.telemetry_enabled;
-    wizardUsed = true;
-  }
-  const effectivePreset = chosenPreset ?? "minimal";
-  const settings = cloneDefaults();
-  settings.id_prefix = normalizedPrefix;
-  applyGovernancePreset(settings, effectivePreset);
-  if (params.normalizedOptions.authorFromOption !== void 0) {
-    settings.author_default = params.normalizedOptions.authorFromOption;
-  }
-  if (chosenTelemetryEnabled !== void 0) {
-    settings.telemetry.enabled = chosenTelemetryEnabled;
-    settings.telemetry.first_run_prompt_completed = true;
-  }
-  await writeSettings(params.pmRoot, settings);
-  return {
-    settings,
-    normalizedPrefix,
-    chosenPreset,
-    wizardUsed
-  };
-}
-async function resolveInitSettings(params) {
-  if (params.settingsExists) {
-    return await loadExistingInitSettings(params);
-  }
-  return await createNewInitSettings({
-    pmRoot: params.pmRoot,
-    normalizedPrefix: params.normalizedPrefix,
-    normalizedOptions: params.normalizedOptions
-  });
-}
-async function applyInitAgentGuidance(params) {
-  const agentGuidanceResult = await runInitAgentGuidance({
-    pm_root: params.pmRoot,
-    cwd: params.cwd,
-    mode: params.agentGuidanceMode,
-    interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
-    settings: params.settings
-  });
-  params.warnings.push(...agentGuidanceResult.warnings);
-  if (agentGuidanceResult.settings_changed) {
-    await writeSettings(params.pmRoot, params.settings);
-  }
-  return {
-    ...agentGuidanceResult.summary,
-    next_steps: agentGuidanceResult.next_steps
-  };
-}
-async function ensureInitRuntimeSchemaFiles(pmRoot, settings) {
-  const createdDirs = [];
-  const warnings = [];
-  const runtimeSchemaScaffold = await ensureRuntimeSchemaFileScaffold(pmRoot, settings.schema);
-  for (const createdPath of runtimeSchemaScaffold.created_paths) {
-    createdDirs.push(createdPath);
-    warnings.push(...await runActiveOnWriteHooks({
-      path: createdPath,
-      scope: "project",
-      op: "init:runtime_schema_file"
-    }));
-  }
-  return { createdDirs, warnings };
-}
-async function maybeRegisterInitTypePreset(params) {
-  if (params.typePreset === void 0) {
-    return void 0;
-  }
-  const registeredTypePreset = await registerInitTypePreset(params.pmRoot, params.settings, params.typePreset);
-  params.warnings.push(`registered_type_preset:${params.typePreset}`);
-  params.warnings.push(...await runActiveOnWriteHooks({
-    path: registeredTypePreset.file,
-    scope: "project",
-    op: "init:type_preset"
-  }));
-  return registeredTypePreset;
-}
-async function ensureInitTypeDirectories(params) {
-  const typeRegistry = resolveItemTypeRegistry(params.settings, getActiveExtensionRegistrations());
-  const customTypeFolders = typeRegistry.folders.filter((folder) => !PM_REQUIRED_SUBDIRS.includes(folder));
-  const scaffold = await ensureInitDirectories(params.pmRoot, customTypeFolders);
-  params.createdDirs.push(...scaffold.createdDirs);
-  params.warnings.push(...scaffold.warnings);
-}
-async function maybeInstallInitBundledPackages(installBundledPackages, global, warnings) {
-  if (!installBundledPackages) {
-    return void 0;
-  }
-  const packageInstallResult = await runExtension("all", { install: true, project: true }, global);
-  warnings.push(...packageInstallResult.warnings);
-  const installedPackages = summarizeInstalledPackages(packageInstallResult);
-  if (!installedPackages.installed_all || installedPackages.packages.some((entry) => !entry.ok)) {
-    throw new PmCliError("pm init --with-packages did not install all bundled packages successfully.", EXIT_CODE.GENERIC_FAILURE);
-  }
-  return installedPackages;
-}
-function buildInitNextSteps(params) {
-  const nextSteps = [
-    'Create your first item: pm create --type Task --title "<title>"',
-    "List active items: pm list",
-    "Get agent-friendly project context: pm context"
-  ];
-  if (!params.installBundledPackages) {
-    nextSteps.push("Add optional packages for richer workflows: pm install calendar --project, pm install templates --project, pm install guide-shell --project");
-    nextSteps.push("Or install everything bundled: pm init --with-packages (idempotent on re-run)");
-  } else {
-    nextSteps.push("Explore newly-available commands: pm cal, pm templates, pm guide");
-  }
-  if (params.registeredTypePreset) {
-    nextSteps.push(`Inspect registered preset types: pm schema list, pm schema show ${params.registeredTypePreset.registered[0] ?? params.registeredTypePreset.updated[0]}`);
-  }
-  nextSteps.push("Set PM_AUTHOR=<your-agent-id> so mutations attribute to the right caller.");
-  for (const guidanceNextStep of params.agentGuidanceNextSteps) {
-    if (!nextSteps.includes(guidanceNextStep)) {
-      nextSteps.push(guidanceNextStep);
-    }
-  }
-  return nextSteps;
-}
-async function runInit(prefixArg, global, options = {}) {
-  const cwd = process.cwd();
-  const invocation = resolveInitInvocation(cwd, global, prefixArg);
-  const pmRoot = invocation.pmRoot;
-  prefixArg = invocation.prefixArg;
-  await assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, global, options.force === true);
-  const createdDirs = [];
-  const warnings = [];
-  const baseDirs = await ensureInitDirectories(pmRoot, PM_REQUIRED_SUBDIRS);
-  createdDirs.push(...baseDirs.createdDirs);
-  warnings.push(...baseDirs.warnings);
-  const settingsPath = path2.join(pmRoot, "settings.json");
-  const settingsExists = await pathExists(settingsPath);
-  const normalizedOptions = normalizeInitCommandOptions(options);
-  const settingsResolution = await resolveInitSettings({
-    pmRoot,
-    settingsPath,
-    settingsExists,
-    normalizedPrefix: normalizePrefix(prefixArg),
-    prefixArg,
-    options,
-    normalizedOptions,
-    warnings
-  });
-  let { settings } = settingsResolution;
-  const agentGuidance = await applyInitAgentGuidance({
-    pmRoot,
-    cwd,
-    agentGuidanceMode: normalizedOptions.agentGuidanceMode,
-    settings,
-    warnings
-  });
-  const schemaFiles = await ensureInitRuntimeSchemaFiles(pmRoot, settings);
-  createdDirs.push(...schemaFiles.createdDirs);
-  warnings.push(...schemaFiles.warnings);
-  const registeredTypePreset = await maybeRegisterInitTypePreset({
-    pmRoot,
-    settings,
-    typePreset: normalizedOptions.typePreset,
-    warnings
-  });
-  if (registeredTypePreset) {
-    settings = await readSettings(pmRoot);
-  }
-  await ensureInitTypeDirectories({ pmRoot, settings, createdDirs, warnings });
-  const installedPackages = await maybeInstallInitBundledPackages(normalizedOptions.installBundledPackages, global, warnings);
-  const nextSteps = buildInitNextSteps({
-    installBundledPackages: normalizedOptions.installBundledPackages,
-    registeredTypePreset,
-    agentGuidanceNextSteps: agentGuidance.next_steps
-  });
-  return {
-    ok: true,
-    path: pmRoot,
-    settings,
-    created_dirs: createdDirs,
-    warnings,
-    governance_preset: settings.governance.preset,
-    wizard_used: settingsResolution.wizardUsed,
-    ...registeredTypePreset ? { registered_type_preset: registeredTypePreset } : {},
-    ...installedPackages ? { installed_packages: installedPackages } : {},
-    next_steps: nextSteps,
-    agent_guidance: agentGuidance
-  };
-}
-
-export {
-  summarizeInitResult,
-  _testOnly,
-  runInit
-};
-//# sourceMappingURL=chunk-MFSCBT5Q.js.map
-
-//# debugId=60eff3e2-3dae-547d-af75-15d1de75a9b5