@unbrained/pm-cli 2026.5.31 → 2026.6.6

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

@@ -0,0 +1,751 @@
+
+!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]="256a39f4-fc97-5137-9150-eb04dce607f8")}catch(e){}}();
+import {
+  normalizeAddTypeInput,
+  parseItemTypesFile,
+  serializeItemTypesFile,
+  upsertItemType
+} from "./chunk-6P6GGMOG.js";
+import {
+  runExtension
+} from "./chunk-TPH5XEVD.js";
+import {
+  normalizePrefix
+} from "./chunk-HZGUAH22.js";
+import {
+  resolveItemTypeRegistry
+} from "./chunk-2VBQ6ZXS.js";
+import {
+  DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
+  EXIT_CODE,
+  GOVERNANCE_PRESET_DEFAULTS,
+  PM_REQUIRED_SUBDIRS,
+  PmCliError,
+  SETTINGS_DEFAULTS,
+  ensureRuntimeSchemaFileScaffold,
+  filePathForSchemaSection,
+  getActiveExtensionRegistrations,
+  normalizeRuntimeSchemaSettings,
+  pathExists,
+  readFileIfExists,
+  readSettings,
+  resolvePmRoot,
+  runActiveOnWriteHooks,
+  writeFileAtomic,
+  writeSettings
+} from "./chunk-5SFCOO6B.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 -->";
+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 nextContent2 = ensureTrailingNewline(`${existingContent.slice(0, existingRange.start_index)}${nextBlock}${existingContent.slice(existingRange.end_index)}`);
+    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 = readline.createInterface({ input, output });
+  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"
+    })
+  };
+}
+async function runInitAgentGuidance(options) {
+  const warnings = [];
+  const nextSteps = [];
+  const projectRoot = resolveProjectRoot(options.pm_root, options.cwd);
+  let scans = await scanGuidanceFiles(projectRoot);
+  const targetPath = resolveTargetGuidancePath(scans, projectRoot);
+  const targetRelativePath = toPortableRelativePath(projectRoot, targetPath);
+  const addLaterHint = "Add workflow guidance later: pm init --agent-guidance add";
+  let prompted = false;
+  let applied = false;
+  let skipped = false;
+  let state = normalizeAgentGuidanceState(options.settings);
+  const checkedFiles = scans.map((entry) => toPortableRelativePath(projectRoot, entry.file_path));
+  const presentBefore = scans.some((entry) => entry.has_guidance);
+  const markState = (partial) => {
+    state = {
+      ...state,
+      ...partial,
+      template_version: AGENT_GUIDANCE_TEMPLATE_VERSION,
+      last_checked_files: checkedFiles
+    };
+  };
+  if (options.mode === "status") {
+    if (!presentBefore) {
+      warnings.push("agent_guidance:missing");
+      pushUnique(nextSteps, addLaterHint);
+    }
+  } else if (options.mode === "skip") {
+    skipped = true;
+    markState({
+      prompt_completed: true,
+      declined: true,
+      declined_at: state.declined_at.length > 0 ? state.declined_at : (/* @__PURE__ */ new Date()).toISOString()
+    });
+    warnings.push("agent_guidance:explicit_skip");
+    pushUnique(nextSteps, addLaterHint);
+  } else if (options.mode === "add") {
+    if (!presentBefore) {
+      const writeResult = await writeGuidanceFile(targetPath);
+      warnings.push(...writeResult.warnings);
+      if (writeResult.changed) {
+        applied = true;
+        warnings.push(`agent_guidance:added:${targetRelativePath}`);
+      }
+    }
+    markState({
+      prompt_completed: true,
+      declined: false,
+      declined_at: ""
+    });
+  } else if (presentBefore) {
+    if (state.declined) {
+      markState({
+        prompt_completed: true,
+        declined: false,
+        declined_at: ""
+      });
+    }
+  } else if (state.prompt_completed && state.declined) {
+    skipped = true;
+    warnings.push("agent_guidance:skipped_declined");
+    pushUnique(nextSteps, addLaterHint);
+  } else if (options.interactive) {
+    prompted = true;
+    const approved = await promptForGuidanceWrite(targetRelativePath);
+    if (approved) {
+      const writeResult = await writeGuidanceFile(targetPath);
+      warnings.push(...writeResult.warnings);
+      if (writeResult.changed) {
+        applied = true;
+        warnings.push(`agent_guidance:added:${targetRelativePath}`);
+      }
+      markState({
+        prompt_completed: true,
+        declined: false,
+        declined_at: ""
+      });
+    } else {
+      skipped = true;
+      markState({
+        prompt_completed: true,
+        declined: true,
+        declined_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      warnings.push("agent_guidance:declined");
+      pushUnique(nextSteps, addLaterHint);
+    }
+  } else {
+    warnings.push("agent_guidance:missing_non_interactive");
+    pushUnique(nextSteps, addLaterHint);
+  }
+  const stateUpdate = applyAgentGuidanceState(options.settings, state);
+  if (applied) {
+    scans = await scanGuidanceFiles(projectRoot);
+  }
+  const summary = {
+    mode: options.mode,
+    present: scans.some((entry) => entry.has_guidance),
+    prompted,
+    applied,
+    skipped,
+    declined: state.declined,
+    prompt_completed: state.prompt_completed,
+    template_version: state.template_version,
+    target_file: targetRelativePath,
+    checked_files: scans.map((entry) => toPortableRelativePath(projectRoot, entry.file_path)),
+    files_with_guidance: scans.filter((entry) => entry.has_guidance).map((entry) => toPortableRelativePath(projectRoot, entry.file_path)),
+    missing_files: scans.filter((entry) => !entry.exists).map((entry) => toPortableRelativePath(projectRoot, entry.file_path))
+  };
+  return {
+    summary,
+    warnings,
+    next_steps: 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."
+  };
+}
+function cloneDefaults() {
+  return structuredClone(SETTINGS_DEFAULTS);
+}
+var BUILTIN_GOVERNANCE_PRESETS = ["minimal", "default", "strict"];
+var INIT_TYPE_PRESET_NAMES = ["agile", "ops", "research"];
+var INIT_TYPE_PRESET_DEFINITIONS = {
+  agile: [
+    {
+      name: "Story",
+      description: "User-facing outcome or capability slice expressed from a stakeholder perspective.",
+      defaultStatus: "open",
+      folder: "stories",
+      aliases: ["user-story"]
+    },
+    {
+      name: "Spike",
+      description: "Time-boxed investigation used to reduce uncertainty before implementation.",
+      defaultStatus: "open",
+      folder: "spikes",
+      aliases: ["research-spike"]
+    }
+  ],
+  ops: [
+    {
+      name: "Incident",
+      description: "Operational disruption, degradation, or support escalation with recovery tracking.",
+      defaultStatus: "open",
+      folder: "incidents",
+      aliases: ["outage"]
+    },
+    {
+      name: "Runbook",
+      description: "Repeatable operational procedure, diagnostic path, or response playbook.",
+      defaultStatus: "open",
+      folder: "runbooks",
+      aliases: ["playbook"]
+    }
+  ],
+  research: [
+    {
+      name: "Experiment",
+      description: "Validated-learning activity with hypothesis, method, and outcome tracking.",
+      defaultStatus: "open",
+      folder: "experiments",
+      aliases: ["study"]
+    },
+    {
+      name: "Hypothesis",
+      description: "Testable claim or assumption that should be supported, rejected, or refined.",
+      defaultStatus: "open",
+      folder: "hypotheses",
+      aliases: ["assumption"]
+    }
+  ]
+};
+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;
+  }
+  const normalized = rawValue.trim().toLowerCase().replaceAll("-", "_");
+  if (normalized.length === 0) {
+    throw new PmCliError("--type-preset must not be empty", EXIT_CODE.USAGE);
+  }
+  if (normalized === "agile" || normalized === "ops" || normalized === "research") {
+    return normalized;
+  }
+  throw new PmCliError(`Invalid --type-preset value "${rawValue}". Allowed: ${INIT_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 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 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.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 rawDefinition of INIT_TYPE_PRESET_DEFINITIONS[preset]) {
+    const normalized = normalizeAddTypeInput(rawDefinition);
+    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 runInitWizard(initialPrefix, telemetryDefault) {
+  const rl = readline2.createInterface({ input: input2, output: output2 });
+  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 resolvedPreset = normalizeInitGovernancePreset(presetAnswer.trim().length > 0 ? presetAnswer : "minimal") ?? "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();
+  }
+}
+async function runInit(prefixArg, global, options = {}) {
+  const cwd = process.cwd();
+  const pmRoot = resolvePmRoot(cwd, global.path);
+  const createdDirs = [];
+  const warnings = [];
+  let wizardUsed = false;
+  for (const subdir of PM_REQUIRED_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"
+    }));
+  }
+  const settingsPath = path2.join(pmRoot, "settings.json");
+  const settingsExists = await pathExists(settingsPath);
+  let normalizedPrefix = normalizePrefix(prefixArg);
+  const presetFromOption = normalizeInitGovernancePreset(options.preset);
+  const useDefaults = options.defaults === true;
+  const authorFromOption = normalizeOptionalInitAuthor(options.author);
+  const installBundledPackages = options.withPackages === true;
+  const agentGuidanceMode = normalizeInitAgentGuidanceMode(options.agentGuidance);
+  const typePreset = normalizeInitTypePreset(options.typePreset);
+  let chosenPreset = presetFromOption;
+  let chosenTelemetryEnabled;
+  let settings;
+  if (settingsExists) {
+    settings = await readSettings(pmRoot);
+    warnings.push(`already_exists:${settingsPath}`);
+    let changed = false;
+    if (prefixArg !== void 0 && settings.id_prefix !== normalizedPrefix) {
+      settings.id_prefix = normalizedPrefix;
+      warnings.push(`updated:id_prefix:${normalizedPrefix}`);
+      changed = true;
+    }
+    if (presetFromOption !== void 0 && settings.governance.preset !== presetFromOption) {
+      applyGovernancePreset(settings, presetFromOption);
+      warnings.push(`updated:governance_preset:${presetFromOption}`);
+      changed = true;
+    }
+    if (authorFromOption !== void 0 && settings.author_default !== authorFromOption) {
+      settings.author_default = authorFromOption;
+      warnings.push(`updated:author_default:${authorFromOption}`);
+      changed = true;
+    }
+    if (changed) {
+      await writeSettings(pmRoot, settings);
+    }
+  } else {
+    if (presetFromOption === void 0 && !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";
+    settings = cloneDefaults();
+    settings.id_prefix = normalizedPrefix;
+    applyGovernancePreset(settings, effectivePreset);
+    if (authorFromOption !== void 0) {
+      settings.author_default = authorFromOption;
+    }
+    if (chosenTelemetryEnabled !== void 0) {
+      settings.telemetry.enabled = chosenTelemetryEnabled;
+      settings.telemetry.first_run_prompt_completed = true;
+    }
+    await writeSettings(pmRoot, settings);
+  }
+  const agentGuidanceResult = await runInitAgentGuidance({
+    pm_root: pmRoot,
+    cwd,
+    mode: agentGuidanceMode,
+    interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
+    settings
+  });
+  warnings.push(...agentGuidanceResult.warnings);
+  if (agentGuidanceResult.settings_changed) {
+    await writeSettings(pmRoot, settings);
+  }
+  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"
+    }));
+  }
+  let registeredTypePreset;
+  if (typePreset !== void 0) {
+    registeredTypePreset = await registerInitTypePreset(pmRoot, settings, typePreset);
+    warnings.push(`registered_type_preset:${typePreset}`);
+    warnings.push(...await runActiveOnWriteHooks({
+      path: registeredTypePreset.file,
+      scope: "project",
+      op: "init:type_preset"
+    }));
+    settings = await readSettings(pmRoot);
+  }
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  for (const typeFolder of typeRegistry.folders) {
+    if (PM_REQUIRED_SUBDIRS.includes(typeFolder)) {
+      continue;
+    }
+    const target = path2.join(pmRoot, typeFolder);
+    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"
+    }));
+  }
+  let installedPackages;
+  if (installBundledPackages) {
+    const packageInstallResult = await runExtension("all", { install: true, project: true }, global);
+    warnings.push(...packageInstallResult.warnings);
+    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);
+    }
+  }
+  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 (!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 (registeredTypePreset) {
+    nextSteps.push(`Inspect registered preset types: pm schema list, pm schema show ${registeredTypePreset.registered[0] ?? registeredTypePreset.updated[0]}`);
+  }
+  nextSteps.push("Set PM_AUTHOR=<your-agent-id> so mutations attribute to the right caller.");
+  for (const guidanceNextStep of agentGuidanceResult.next_steps) {
+    if (!nextSteps.includes(guidanceNextStep)) {
+      nextSteps.push(guidanceNextStep);
+    }
+  }
+  return {
+    ok: true,
+    path: pmRoot,
+    settings,
+    created_dirs: createdDirs,
+    warnings,
+    governance_preset: settings.governance.preset,
+    wizard_used: wizardUsed,
+    ...registeredTypePreset ? { registered_type_preset: registeredTypePreset } : {},
+    ...installedPackages ? { installed_packages: installedPackages } : {},
+    next_steps: nextSteps,
+    agent_guidance: agentGuidanceResult.summary
+  };
+}
+
+export {
+  summarizeInitResult,
+  runInit
+};
+//# sourceMappingURL=chunk-AY43SBIN.js.map
+
+//# debugId=256a39f4-fc97-5137-9150-eb04dce607f8