@unbrained/pm-cli 2026.7.14 → 2026.7.16

package/dist/cli/commands/init.js

@@ -1,696 +1,10 @@
 /**
  * @module cli/commands/init
  *
- * Implements the pm init command surface and its agent-facing runtime behavior.
+ * Preserves the CLI compatibility import path for SDK-owned initialization primitives.
  */
 
-!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]="1ea1882d-85c9-5e7e-b137-55871fc0dcb5")}catch(e){}}();
-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";
-import { getActiveExtensionRegistrations, runActiveOnWriteHooks, } from "../../core/extensions/index.js";
-import { pathExists, readFileIfExists, writeFileAtomic, } from "../../core/fs/fs-utils.js";
-import { normalizePrefix } from "../../core/item/id.js";
-import { resolveItemTypeRegistry } from "../../core/item/type-registry.js";
-import { DEFAULT_RUNTIME_SCHEMA_FILE_PATHS, ensureRuntimeSchemaFileScaffold, filePathForSchemaSection, normalizeRuntimeSchemaSettings, } from "../../core/schema/runtime-schema.js";
-import { parseItemTypesFile, serializeItemTypesFile, upsertItemType, } from "../../core/schema/item-types-file.js";
-import { normalizeTypePresetName, resolveTypePresetDefinitions, TYPE_PRESET_NAMES, } from "../../core/schema/type-presets.js";
-import { EXIT_CODE, GOVERNANCE_PRESET_DEFAULTS, PM_REQUIRED_SUBDIRS, SETTINGS_DEFAULTS, } from "../../core/shared/constants.js";
-import { PmCliError } from "../../core/shared/errors.js";
-import { resolvePmRoot } from "../../core/store/paths.js";
-import { readSettings, writeSettings } from "../../core/store/settings.js";
-import { ensurePmGitignore } from "../../sdk/workspace.js";
-import { renderPmCommand } from "../argv-utils.js";
-import { runExtension } from "./extension.js";
-import { INIT_AGENT_GUIDANCE_MODE_VALUES, runInitAgentGuidance, } from "./init-agent-guidance.js";
-/** Implements summarize init result for the public runtime surface of this module. */
-export function summarizeInitResult(result) {
-    return {
-        ok: result.ok,
-        path: result.path,
-        target: result.target,
-        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.",
-    };
-}
-/** Public contract for test only, shared by SDK and presentation-layer consumers. */
-export const _testOnly = {
-    normalizeInitGovernancePreset,
-    normalizeInitTypePreset,
-    normalizeOptionalInitAuthor,
-    normalizeInitAgentGuidanceMode,
-    isPathLikeInitTarget,
-    resolveInitInvocation,
-    parseYesNoChoice,
-    applyGovernancePreset,
-    runInitWizard,
-    setInitReadlineFactoryForTests,
-    summarizeInstalledPackages,
-    buildInitNextSteps,
-    registerInitTypePreset,
-    assertExplicitTrackerPathIsNotWorkspaceRoot,
-    isLikelyWorkspaceRoot,
-};
-let createInitReadlineInterface = () => readline.createInterface({ input, output });
-function setInitReadlineFactoryForTests(factory) {
-    createInitReadlineInterface =
-        factory ?? (() => readline.createInterface({ input, output }));
-}
-function cloneDefaults() {
-    return structuredClone(SETTINGS_DEFAULTS);
-}
-const BUILTIN_GOVERNANCE_PRESETS = [
-    "minimal",
-    "default",
-    "strict",
-];
-function normalizeInitGovernancePreset(rawValue) {
-    if (rawValue === undefined) {
-        return undefined;
-    }
-    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 === undefined) {
-        return undefined;
-    }
-    if (rawValue.trim().length === 0) {
-        throw new PmCliError("--type-preset must not be empty", EXIT_CODE.USAGE);
-    }
-    try {
-        // Non-undefined input never returns undefined; the shared normalizer throws
-        // a plain Error for empty/unknown values, which we re-map to init's --type-preset
-        // PmCliError wording for a consistent CLI surface.
-        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 === undefined) {
-        return undefined;
-    }
-    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 === undefined) {
-        return false;
-    }
-    const trimmed = rawValue.trim();
-    if (trimmed.length === 0) {
-        return false;
-    }
-    return (path.isAbsolute(trimmed) ||
-        trimmed.startsWith(".") ||
-        trimmed.includes("/") ||
-        trimmed.includes("\\"));
-}
-function resolveInitInvocation(cwd, global, prefixArg, workspaceArg) {
-    const normalizedWorkspace = workspaceArg?.trim();
-    if (workspaceArg !== undefined && normalizedWorkspace?.length === 0) {
-        throw new PmCliError("--workspace must not be empty", EXIT_CODE.USAGE);
-    }
-    if (normalizedWorkspace !== undefined) {
-        if (global.path !== undefined || isPathLikeInitTarget(prefixArg)) {
-            throw new PmCliError("--workspace cannot be combined with --pm-path/--path or a path-like positional target.", EXIT_CODE.USAGE);
-        }
-        const workspaceRoot = path.resolve(cwd, normalizedWorkspace);
-        const pmRoot = path.join(workspaceRoot, ".agents", "pm");
-        return {
-            pmRoot,
-            prefixArg,
-            target: {
-                mode: "workspace-path",
-                tracker_root: pmRoot,
-                workspace_root: workspaceRoot,
-            },
-        };
-    }
-    if (global.path === undefined && isPathLikeInitTarget(prefixArg)) {
-        const positionalTarget = path.resolve(cwd, prefixArg.trim());
-        return {
-            pmRoot: positionalTarget,
-            prefixArg: undefined,
-            target: { mode: "tracker-path", tracker_root: positionalTarget },
-        };
-    }
-    const pmRoot = resolvePmRoot(cwd, global.path);
-    return {
-        pmRoot,
-        prefixArg,
-        target: global.path === undefined
-            ? {
-                mode: "workspace-discovery",
-                tracker_root: pmRoot,
-                workspace_root: cwd,
-            }
-            : { mode: "tracker-path", tracker_root: pmRoot },
-    };
-}
-function normalizeInitAgentGuidanceMode(rawValue) {
-    if (rawValue === undefined) {
-        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",
-        path.join(".agents", "pm"),
-    ];
-    for (const indicator of indicators) {
-        if (await pathExists(path.join(candidate, indicator))) {
-            return true;
-        }
-    }
-    return false;
-}
-async function assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, explicitTrackerTarget, force) {
-    if (!explicitTrackerTarget || force) {
-        return;
-    }
-    if (await pathExists(path.join(pmRoot, "settings.json"))) {
-        return;
-    }
-    if (!(await isLikelyWorkspaceRoot(pmRoot))) {
-        return;
-    }
-    const nestedTracker = path.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: "Path-like init targets and --pm-path/--path point at the tracker storage directory itself, not the repository workspace. Point at .agents/pm, use --workspace, 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 ? path.join(pmRoot, subdir) : pmRoot;
-        const existed = await pathExists(target);
-        await fs.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 {
-        output.write("pm init setup wizard (agent-optimized)\n");
-        output.write("This walkthrough is non-destructive and each choice can be changed later with pm config.\n\n");
-        output.write("1/3 Item ID prefix\n");
-        output.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;
-        output.write("\n2/3 Governance preset\n");
-        output.write("minimal: no ownership blocking, progressive create defaults, close validation off.\n");
-        output.write("default: ownership conflict warnings, progressive create defaults, close validation warn.\n");
-        output.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";
-        // The wizard is forgiving: a typo'd/unknown preset defaults to minimal with a
-        // notice instead of throwing and aborting an in-progress interactive setup.
-        // normalizeInitGovernancePreset returns a concrete preset for valid input and
-        // throws (never returns undefined) for invalid non-empty input, so the result is
-        // always a BuiltinGovernancePreset on the success path.
-        let resolvedPreset = "minimal";
-        try {
-            resolvedPreset = normalizeInitGovernancePreset(presetChoice);
-        }
-        catch {
-            output.write(`Unrecognized governance preset "${presetChoice}"; using minimal.\n`);
-        }
-        output.write("\n3/3 Project telemetry\n");
-        output.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);
-        output.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 !== undefined &&
-        params.settings.id_prefix !== params.normalizedPrefix) {
-        pendingChanges.push("id_prefix");
-    }
-    if (params.presetFromOption !== undefined &&
-        params.settings.governance.preset !== params.presetFromOption) {
-        pendingChanges.push("governance_preset");
-    }
-    if (params.authorFromOption !== undefined &&
-        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 !== undefined &&
-        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 !== undefined &&
-        params.settings.governance.preset !== params.presetFromOption) {
-        applyGovernancePreset(params.settings, params.presetFromOption);
-        params.warnings.push(`updated:governance_preset:${params.presetFromOption}`);
-        changed = true;
-    }
-    if (params.authorFromOption !== undefined &&
-        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 === undefined &&
-        !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 !== undefined) {
-        settings.author_default = params.normalizedOptions.authorFromOption;
-    }
-    if (chosenTelemetryEnabled !== undefined) {
-        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 === undefined) {
-        return undefined;
-    }
-    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);
-}
-function resolveInitWorkspaceRoot(target) {
-    const trackerRoot = path.resolve(target.tracker_root);
-    const agentsRoot = path.dirname(trackerRoot);
-    if (path.basename(trackerRoot) === "pm" && path.basename(agentsRoot) === ".agents") {
-        return path.dirname(agentsRoot);
-    }
-    return target.workspace_root;
-}
-async function maybeInstallInitBundledPackages(installBundledPackages, global, pmRoot, warnings) {
-    if (!installBundledPackages) {
-        return undefined;
-    }
-    const packageInstallResult = await runExtension("all", { install: true, project: true }, { ...global, path: pmRoot });
-    warnings.push(...packageInstallResult.warnings);
-    const installedPackages = summarizeInstalledPackages(packageInstallResult);
-    const failedAliases = installedPackages.packages
-        .filter((entry) => !entry.ok)
-        .map((entry) => entry.alias);
-    if (!installedPackages.installed_all || failedAliases.length > 0) {
-        throw new PmCliError(`pm init --with-packages did not install all bundled packages successfully${failedAliases.length > 0 ? `: ${failedAliases.join(", ")}` : "."}`, EXIT_CODE.GENERIC_FAILURE);
-    }
-    return installedPackages;
-}
-function buildInitNextSteps(params) {
-    const pmCommand = (args) => renderPmCommand([
-        ...(params.target.mode === "workspace-discovery"
-            ? []
-            : ["--pm-path", params.target.tracker_root]),
-        ...args,
-    ]);
-    const nextSteps = [
-        `Create your first item: ${pmCommand(["create", "--type", "Task", "--title", "<title>"])}`,
-        `List active items: ${pmCommand(["list"])}`,
-        `Get agent-friendly project context: ${pmCommand(["context"])}`,
-    ];
-    if (!params.installBundledPackages) {
-        nextSteps.push(`Add optional packages for richer workflows: ${pmCommand(["install", "calendar", "--project"])}, ${pmCommand(["install", "templates", "--project"])}, ${pmCommand(["install", "guide-shell", "--project"])}`);
-        nextSteps.push(`Or install everything bundled: ${pmCommand(["init", "--with-packages"])} (idempotent on re-run)`);
-    }
-    else {
-        nextSteps.push(`Explore newly-available commands: ${pmCommand(["cal"])}, ${pmCommand(["templates"])}, ${pmCommand(["guide"])}`);
-    }
-    if (params.registeredTypePreset) {
-        nextSteps.push(`Inspect registered preset types: ${pmCommand(["schema", "list"])}, ${pmCommand(["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) {
-        const scopedGuidance = params.target.mode === "workspace-discovery"
-            ? guidanceNextStep
-            : guidanceNextStep.replace(/\bpm (?=[a-z])/g, () => `${pmCommand([])} `);
-        if (!nextSteps.includes(scopedGuidance)) {
-            nextSteps.push(scopedGuidance);
-        }
-    }
-    return nextSteps;
-}
-/** Implements run init for the public runtime surface of this module. */
-export async function runInit(prefixArg, global, options = {}) {
-    const cwd = process.cwd();
-    const invocation = resolveInitInvocation(cwd, global, prefixArg, options.workspace);
-    const pmRoot = invocation.pmRoot;
-    prefixArg = invocation.prefixArg;
-    await assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, invocation.target.mode === "tracker-path", 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 = path.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 workspaceRoot = resolveInitWorkspaceRoot(invocation.target);
-    if (workspaceRoot) {
-        const gitignore = await ensurePmGitignore(workspaceRoot);
-        if (gitignore.changed) {
-            warnings.push(`updated:gitignore:${gitignore.path}`);
-        }
-    }
-    const installedPackages = await maybeInstallInitBundledPackages(normalizedOptions.installBundledPackages, global, pmRoot, warnings);
-    const nextSteps = buildInitNextSteps({
-        installBundledPackages: normalizedOptions.installBundledPackages,
-        registeredTypePreset,
-        agentGuidanceNextSteps: agentGuidance.next_steps,
-        target: invocation.target,
-    });
-    return {
-        ok: true,
-        path: pmRoot,
-        target: invocation.target,
-        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,
-    };
-}
+!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]="0d10e7b8-b8f0-5958-87b9-c0f6d73c08c9")}catch(e){}}();
+export * from "../../sdk/init.js";
 //# sourceMappingURL=init.js.map
-//# debugId=1ea1882d-85c9-5e7e-b137-55871fc0dcb5
+//# debugId=0d10e7b8-b8f0-5958-87b9-c0f6d73c08c9