@unbrained/pm-cli 2026.7.1 → 2026.7.3

package/dist/cli-bundle/chunks/{chunk-V3NOKJF2.js → chunk-MHRS5FUX.js}

@@ -1,21 +1,21 @@
 
-!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]="5826efe9-1f8d-5de5-8771-4f25b48dcabf")}catch(e){}}();
+!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]="c459dd56-fee6-5a66-a018-a16c877d7490")}catch(e){}}();
 import {
   runExtension
-} from "./chunk-NU2UEROZ.js";
+} from "./chunk-YF746GTH.js";
 import {
   TYPE_PRESET_NAMES,
   normalizeTypePresetName,
   resolveTypePresetDefinitions
-} from "./chunk-2D4HATP2.js";
+} from "./chunk-EJ2OCBHF.js";
 import {
   parseItemTypesFile,
   serializeItemTypesFile,
   upsertItemType
-} from "./chunk-MAUKX7JC.js";
+} from "./chunk-GVJE5T7Q.js";
 import {
   normalizePrefix
-} from "./chunk-JSU5P7VS.js";
+} from "./chunk-4WB6S4YX.js";
 import {
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
   EXIT_CODE,
@@ -35,7 +35,7 @@ import {
   runActiveOnWriteHooks,
   writeFileAtomic,
   writeSettings
-} from "./chunk-7R4QEMZZ.js";
+} from "./chunk-L4SLHV6G.js";
 
 // dist/cli/commands/init.js
 import fs2 from "node:fs/promises";
@@ -246,6 +246,25 @@ async function writeGuidanceFile(filePath) {
     })
   };
 }
+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;
+}
 async function runInitAgentGuidance(options) {
   const warnings = [];
   const nextSteps = [];
@@ -338,23 +357,17 @@ async function runInitAgentGuidance(options) {
     pushUnique(nextSteps, addLaterHint);
   }
   const stateUpdate = applyAgentGuidanceState(options.settings, state);
-  if (applied) {
-    scans = await scanGuidanceFiles(projectRoot);
-  }
-  const summary = {
+  scans = await refreshGuidanceScansAfterApply(applied, scans, projectRoot);
+  const summary = buildInitAgentGuidanceSummary({
     mode: options.mode,
-    present: scans.some((entry) => entry.has_guidance),
+    scans,
+    projectRoot,
+    targetRelativePath,
     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))
-  };
+    state
+  });
   return {
     summary,
     warnings,
@@ -587,6 +600,26 @@ async function assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, global, force
     }
   });
 }
+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 {
@@ -624,126 +657,157 @@ async function runInitWizard(initialPrefix, telemetryDefault) {
     rl.close();
   }
 }
-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 = [];
-  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"
-    }));
+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");
   }
-  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;
+  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 settings;
-  if (settingsExists) {
-    settings = await readSettings(pmRoot);
-    warnings.push(`already_exists:${settingsPath}`);
-    const pendingChanges = [];
-    const shouldUpdatePrefix = prefixArg !== void 0 && settings.id_prefix !== normalizedPrefix;
-    const shouldUpdatePreset = presetFromOption !== void 0 && settings.governance.preset !== presetFromOption;
-    const shouldUpdateAuthor = authorFromOption !== void 0 && settings.author_default !== authorFromOption;
-    if (shouldUpdatePrefix) {
-      pendingChanges.push("id_prefix");
-    }
-    if (shouldUpdatePreset) {
-      pendingChanges.push("governance_preset");
-    }
-    if (shouldUpdateAuthor) {
-      pendingChanges.push("author_default");
-    }
-    if (pendingChanges.length > 0 && options.force !== true) {
-      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."
-        ]
-      });
-    }
-    let changed = false;
-    if (shouldUpdatePrefix) {
-      settings.id_prefix = normalizedPrefix;
-      warnings.push(`updated:id_prefix:${normalizedPrefix}`);
-      changed = true;
-    }
-    if (shouldUpdatePreset) {
-      applyGovernancePreset(settings, presetFromOption);
-      warnings.push(`updated:governance_preset:${presetFromOption}`);
-      changed = true;
-    }
-    if (shouldUpdateAuthor) {
-      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);
+  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: pmRoot,
-    cwd,
-    mode: agentGuidanceMode,
+    pm_root: params.pmRoot,
+    cwd: params.cwd,
+    mode: params.agentGuidanceMode,
     interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
-    settings
+    settings: params.settings
   });
-  warnings.push(...agentGuidanceResult.warnings);
+  params.warnings.push(...agentGuidanceResult.warnings);
   if (agentGuidanceResult.settings_changed) {
-    await writeSettings(pmRoot, settings);
+    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);
@@ -753,65 +817,114 @@ async function runInit(prefixArg, global, options = {}) {
       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);
+  return { createdDirs, warnings };
+}
+async function maybeRegisterInitTypePreset(params) {
+  if (params.typePreset === void 0) {
+    return void 0;
   }
-  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"
-    }));
+  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;
   }
-  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 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 (!installBundledPackages) {
+  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 (registeredTypePreset) {
-    nextSteps.push(`Inspect registered preset types: pm schema list, pm schema show ${registeredTypePreset.registered[0] ?? registeredTypePreset.updated[0]}`);
+  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 agentGuidanceResult.next_steps) {
+  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);
+  let 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,
@@ -819,11 +932,11 @@ async function runInit(prefixArg, global, options = {}) {
     created_dirs: createdDirs,
     warnings,
     governance_preset: settings.governance.preset,
-    wizard_used: wizardUsed,
+    wizard_used: settingsResolution.wizardUsed,
     ...registeredTypePreset ? { registered_type_preset: registeredTypePreset } : {},
     ...installedPackages ? { installed_packages: installedPackages } : {},
     next_steps: nextSteps,
-    agent_guidance: agentGuidanceResult.summary
+    agent_guidance: agentGuidance
   };
 }
 
@@ -832,6 +945,6 @@ export {
   _testOnly,
   runInit
 };
-//# sourceMappingURL=chunk-V3NOKJF2.js.map
+//# sourceMappingURL=chunk-MHRS5FUX.js.map
 
-//# debugId=5826efe9-1f8d-5de5-8771-4f25b48dcabf
+//# debugId=c459dd56-fee6-5a66-a018-a16c877d7490