@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,995 @@
+
+!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