@unbrained/pm-cli 2026.7.8 → 2026.7.10

package/dist/cli-bundle/chunks/{chunk-4OCWJ2AP.js → chunk-BC7QBM2A.js}

@@ -4,16 +4,16 @@ import {
   executeHistoryRewrite,
   resolveHistorySubject,
   writeHistoryRawWithRollback
-} from "./chunk-JH5XDDYS.js";
+} from "./chunk-TM5E2IED.js";
 import {
   resolveAuthor
 } from "./chunk-T5RRNDA7.js";
 import {
   lifecycleClassifierFromStatusRegistry
-} from "./chunk-J6AD3GWC.js";
+} from "./chunk-JNELC5UO.js";
 import {
   readHistoryEntries
-} from "./chunk-6WCXSC5V.js";
+} from "./chunk-ZGDJA6WI.js";
 import {
   cloneEmptyReplayDocument,
   historyEntriesToRaw,
@@ -22,7 +22,7 @@ import {
   toReplayDocument,
   tryApplyReplayPatch,
   verifyHistoryChain
-} from "./chunk-IINCZYM3.js";
+} from "./chunk-62ECRG6J.js";
 import {
   PmCliError,
   createHistoryEntry,
@@ -33,7 +33,7 @@ import {
   readSettings,
   runActiveOnReadHooks,
   runActiveOnWriteHooks
-} from "./chunk-NTOOEVJ4.js";
+} from "./chunk-Y5Q4FEE4.js";
 import {
   EXIT_CODE,
   getSettingsPath,
@@ -42,7 +42,7 @@ import {
   resolveItemTypeRegistry,
   resolvePmRoot,
   resolveRuntimeStatusRegistry
-} from "./chunk-MFLLULHU.js";
+} from "./chunk-TB2CZJAQ.js";
 
 // dist/cli/commands/history-compact.js
 import fs from "node:fs/promises";
@@ -544,6 +544,6 @@ export {
   assertHistoryCompactTarget,
   runHistoryCompactBulk
 };
-//# sourceMappingURL=chunk-4OCWJ2AP.js.map
+//# sourceMappingURL=chunk-BC7QBM2A.js.map
 
 //# debugId=066b9461-1946-5b62-8a6f-777da307c9c0

package/dist/cli-bundle/chunks/{chunk-LD2NBQ5T.js → chunk-BST7GFIX.js}

@@ -5,14 +5,14 @@ import {
   getActiveExtensionRegistrations,
   listAllFrontMatterLight,
   readSettings
-} from "./chunk-NTOOEVJ4.js";
+} from "./chunk-Y5Q4FEE4.js";
 import {
   EXIT_CODE,
   getSettingsPath,
   pathExists,
   resolveItemTypeRegistry,
   resolvePmRoot
-} from "./chunk-MFLLULHU.js";
+} from "./chunk-TB2CZJAQ.js";
 
 // dist/cli/commands/deps.js
 var DEPS_FORMAT_VALUES = ["tree", "graph"];
@@ -215,6 +215,6 @@ export {
   DEPS_COLLAPSE_VALUES,
   runDeps
 };
-//# sourceMappingURL=chunk-LD2NBQ5T.js.map
+//# sourceMappingURL=chunk-BST7GFIX.js.map
 
 //# debugId=7ca68c4d-ec0c-5aed-a5ff-2dd272fb85e7

package/dist/cli-bundle/chunks/{chunk-GE44TQMC.js → chunk-CUBPPDDF.js}

@@ -1,45 +1,47 @@
 
-!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]="dd6181c4-91c1-58ac-92c2-ce5ae31a5816")}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]="704ef87f-4cbc-5841-bb42-d6cfb02586a7")}catch(e){}}();
 import {
   EXECUTABLE_COMMAND_ALIASES,
   normalizeExtensionNameForMatch,
   normalizeManagedDirectoryName,
   normalizeStringList,
   parseExtensionManifest,
+  renderPmCommand,
   validateExtensionDirectory
-} from "./chunk-ZMOPZFVT.js";
+} from "./chunk-AD4HJKQZ.js";
 import {
   describeExtensionActivation,
   renderExtensionSurfaceMarkdown
-} from "./chunk-Z2JQH2MG.js";
+} from "./chunk-MQ632QRB.js";
 import {
   ensureTypeFolderScaffold
-} from "./chunk-FOJEBRDD.js";
+} from "./chunk-P7PDLLCE.js";
 import {
   TYPE_PRESET_NAMES,
   normalizeTypePresetName,
   resolveTypePresetDefinitions
-} from "./chunk-YSRXFGNV.js";
+} from "./chunk-FSD7W7Y2.js";
 import {
   PM_CORE_COMMAND_NAMES
-} from "./chunk-ML27MHNM.js";
+} from "./chunk-2RW5DWHQ.js";
 import {
   parseItemTypesFile,
   serializeItemTypesFile,
   upsertItemType
-} from "./chunk-7QKSLAHB.js";
+} from "./chunk-AIWGQK6K.js";
 import {
   splitCommaList
 } from "./chunk-P4SESZGT.js";
 import {
   PmCliError,
+  createSerialQueue,
   getActiveExtensionRegistrations,
   normalizePrefix,
   nowIso,
   readSettings,
   runActiveOnWriteHooks,
   writeSettings
-} from "./chunk-NTOOEVJ4.js";
+} from "./chunk-Y5Q4FEE4.js";
 import {
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
   EXIT_CODE,
@@ -67,7 +69,7 @@ import {
   resolvePmPackageRootFromModule,
   resolvePmRoot,
   writeFileAtomic
-} from "./chunk-MFLLULHU.js";
+} from "./chunk-TB2CZJAQ.js";
 
 // dist/core/packages/manifest.js
 import fs from "node:fs/promises";
@@ -2508,6 +2510,7 @@ import { execFile as execFile2 } from "node:child_process";
 import fs6 from "node:fs/promises";
 import os2 from "node:os";
 import path6 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify2 } from "node:util";
 
 // dist/cli/commands/extension/managed-state.js
@@ -4553,6 +4556,7 @@ async function listInstalledExtensions(extensionsRoot, scope, settings, state) {
     warnings: warnings.sort((left, right) => left.localeCompare(right))
   };
 }
+var extensionRuntimeProbeQueue = createSerialQueue();
 function summarizeRuntimeCommandPathsForExtension(extensionName, installed) {
   const normalizedName = normalizeExtensionNameForMatch(extensionName);
   const entry = installed.find((candidate) => normalizeExtensionNameForMatch(candidate.name) === normalizedName);
@@ -4570,15 +4574,21 @@ function resolveCommandDiscoveryPackageName(extensionName, source) {
   }
   return extensionName;
 }
-function buildInstallCommandDiscovery(extensionName, source, commandSummary) {
+function buildInstallCommandDiscovery(extensionName, source, commandSummary, activationFailure) {
   const helpCommands = commandSummary.command_paths.map((commandPath) => `pm ${commandPath} --help`);
+  const sdkDependencyMissing = activationFailure?.error.toLowerCase().includes("@unbrained/pm-cli") === true;
+  const nextSteps = commandSummary.command_paths.length > 0 ? [...helpCommands] : ["Run pm package doctor --project --detail deep if expected package commands are missing."];
+  if (sdkDependencyMissing) {
+    nextSteps.unshift("Install @unbrained/pm-cli in the target workspace so declarative package runtime imports resolve, then reinstall the package.");
+  }
   return {
     package_name: resolveCommandDiscoveryPackageName(extensionName, source),
     extension_name: extensionName,
     command_paths: commandSummary.command_paths,
     action_paths: commandSummary.action_paths,
     help_commands: helpCommands,
-    next_steps: commandSummary.command_paths.length > 0 ? helpCommands : ["Run pm package doctor --project --detail deep if expected package commands are missing."]
+    next_steps: nextSteps,
+    ...sdkDependencyMissing ? { sdk_dependency_status: "missing" } : {}
   };
 }
 function summarizeActivationFailureForDiagnostics(failure) {
@@ -4613,24 +4623,46 @@ function resolveInstallRuntimeActivationStatus(extensionName, scope, runtimeInst
   return runtimeInstalledExtension?.activation_status ?? (installActivationFailure ? "failed" : "unknown");
 }
 async function probeRuntimeCommandPathsForInstall(pmRoot, settings, refreshedInstalled, global) {
-  const loadResult = await loadExtensions({
-    pmRoot,
-    settings,
-    cwd: process.cwd(),
-    noExtensions: global.noExtensions === true,
-    reload_token: nextExtensionReloadToken(),
-    cache_bust: true
-  });
-  const activationResult = await activateExtensions({
-    ...loadResult,
-    loaded: loadResult.loaded
+  return extensionRuntimeProbeQueue.enqueue(async () => {
+    const originalPackageRoot = process.env.PM_CLI_PACKAGE_ROOT;
+    process.env.PM_CLI_PACKAGE_ROOT = path6.resolve(path6.dirname(fileURLToPath2(import.meta.url)), "../../..");
+    try {
+      const loadResult = await loadExtensions({
+        pmRoot,
+        settings,
+        cwd: process.cwd(),
+        noExtensions: global.noExtensions === true,
+        reload_token: nextExtensionReloadToken(),
+        cache_bust: true
+      });
+      const activationResult = await activateExtensions({
+        ...loadResult,
+        loaded: loadResult.loaded
+      });
+      const runtimeFailures = [
+        ...loadResult.failed.map((failure) => ({
+          layer: failure.layer,
+          name: failure.name,
+          entry_path: failure.entry_path,
+          error: failure.error
+        })),
+        ...collectActivationFailureDiagnostics(activationResult.failed)
+      ];
+      return {
+        installed: applyDoctorRuntimeActivationState(refreshedInstalled, loadResult, activationResult),
+        warnings: [...loadResult.warnings, ...activationResult.warnings],
+        activation_failures: runtimeFailures,
+        extensions_disabled: loadResult.disabled_by_flag,
+        item_type_registrations: activationResult.registrations.item_types
+      };
+    } finally {
+      if (originalPackageRoot === void 0) {
+        delete process.env.PM_CLI_PACKAGE_ROOT;
+      } else {
+        process.env.PM_CLI_PACKAGE_ROOT = originalPackageRoot;
+      }
+    }
   });
-  return {
-    installed: applyDoctorRuntimeActivationState(refreshedInstalled, loadResult, activationResult),
-    warnings: [...loadResult.warnings, ...activationResult.warnings],
-    activation_failures: collectActivationFailureDiagnostics(activationResult.failed),
-    item_type_registrations: activationResult.registrations.item_types
-  };
 }
 async function checkGithubUpdate(source, gitCommandRunner = runGitCommand) {
   const checkedAt = nowIso();
@@ -4890,9 +4922,9 @@ async function runExtension(target, options, global) {
   const scope = resolveScope(options);
   const resolvedRoots = resolveExtensionRootsForScope(scope, global);
   const warnings = [];
-  const withResult = (details) => {
+  const withResult = (details, ok = true) => {
     const result = {
-      ok: true,
+      ok,
       action,
       scope,
       roots: action === "catalog" && typeof options.fields === "string" && options.fields.trim().length > 0 ? {
@@ -4959,6 +4991,7 @@ async function runExtensionInitAction(ctx) {
       ...options.vocabulary === "package" ? [`Install dependencies: cd ${quotedShellTargetPath}, then run "npm install"`] : [
         `Install type-check dependencies: cd ${quotedShellTargetPath}, then run "npm install -D typescript @types/node @unbrained/pm-cli"`
       ],
+      ...options.vocabulary === "package" && options.declarative === true ? ["Ensure the target workspace can resolve @unbrained/pm-cli before installing this declarative package."] : [],
       `Install the scaffold: ${options.vocabulary === "package" ? "pm install --project" : "pm extension --install --project"} ${quotedTargetPath}`,
       `Smoke-test command path: pm ${scaffold.command_name}`,
       ...options.vocabulary === "package" ? [`Validate the package: cd ${quotedShellTargetPath}, then run "npm run typecheck" and "npm test"`] : [`Type-check the source (optional): cd ${quotedShellTargetPath}, then run "npx tsc --noEmit"`],
@@ -5105,6 +5138,23 @@ async function performExtensionInstallUnderLock(ctx, input3) {
   const commandSummary = summarizeRuntimeCommandPathsForExtension(validated.manifest.name, runtimeProbe.installed);
   const installActivationFailure = findActivationFailureByName(validated.manifest.name, runtimeProbe.activation_failures, scope);
   const runtimeActivationStatus = resolveInstallRuntimeActivationStatus(validated.manifest.name, scope, runtimeProbe.installed, installActivationFailure);
+  const activated = !runtimeProbe.extensions_disabled && runtimeActivationStatus !== "failed";
+  if (!activated) {
+    warnings.push(`extension_install_activation_failed:${scope}:${validated.manifest.name}:${runtimeActivationStatus}`);
+  }
+  const verification = {
+    status: activated ? "ok" : "degraded",
+    target_pm_root: resolvedRoots.pm_root,
+    activation_status: runtimeActivationStatus,
+    activated,
+    registered_commands: commandSummary.command_paths,
+    registered_actions: commandSummary.action_paths,
+    registered_item_types: installedItemTypeDefinitions,
+    health: {
+      status: activated ? "ok" : "degraded",
+      blocking_failure_count: activated ? 0 : 1
+    }
+  };
   return withResult({
     extension: {
       name: validated.manifest.name,
@@ -5117,18 +5167,19 @@ async function performExtensionInstallUnderLock(ctx, input3) {
     destination_path: destinationDirectory,
     overwritten: destinationExists && !installInPlace,
     installed_in_place: installInPlace,
-    activated: true,
+    activated,
     settings_changed: activationChanged,
     runtime_activation_status: runtimeActivationStatus,
     command_paths: commandSummary.command_paths,
     action_paths: commandSummary.action_paths,
-    command_discovery: buildInstallCommandDiscovery(validated.manifest.name, sourceRecord, commandSummary),
+    command_discovery: buildInstallCommandDiscovery(validated.manifest.name, sourceRecord, commandSummary, installActivationFailure),
+    verification,
     activation_diagnostics: {
       failed_count: runtimeProbe.activation_failures.length,
       failed: runtimeProbe.activation_failures,
       installed_extension_failed: installActivationFailure ?? null
     }
-  });
+  }, activated);
 }
 async function runExtensionInstallAction(ctx) {
   const { action, normalizedTarget, resolvedRoots, warnings, options, global, withResult } = ctx;
@@ -5149,9 +5200,11 @@ async function runExtensionInstallAction(ctx) {
     for (const entry of packages) {
       warnings.push(...entry.result.warnings);
     }
+    const installedAll = packages.every((entry) => entry.result.ok);
     return withResult({
-      installed_all: true,
-      installed_count: packages.length,
+      installed_all: installedAll,
+      installed_count: packages.filter((entry) => entry.result.ok).length,
+      failed_count: packages.filter((entry) => !entry.result.ok).length,
       packages: packages.map((entry) => ({
         alias: entry.alias,
         ok: entry.result.ok,
@@ -5163,9 +5216,12 @@ async function runExtensionInstallAction(ctx) {
         command_paths: entry.result.details.command_paths,
         action_paths: entry.result.details.action_paths,
         command_discovery: entry.result.details.command_discovery,
+        verification: entry.result.details.verification,
+        runtime_activation_status: entry.result.details.runtime_activation_status,
+        activation_diagnostics: entry.result.details.activation_diagnostics,
         warnings: entry.result.warnings
       }))
-    });
+    }, installedAll);
   }
   const bundledAliasSource = typeof githubOption === "string" ? null : await resolveBundledExtensionAliasSource(explicitSourceInput);
   const bundledAliasName = bundledAliasSource === null ? null : explicitSourceInput.trim().toLowerCase();
@@ -6166,6 +6222,7 @@ 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: {
@@ -6238,18 +6295,36 @@ function isPathLikeInitTarget(rawValue) {
   }
   return path8.isAbsolute(trimmed) || trimmed.startsWith(".") || trimmed.includes("/") || trimmed.includes("\\");
 }
-function resolveInitInvocation(cwd, global, prefixArg) {
+function resolveInitInvocation(cwd, global, prefixArg, workspaceArg) {
+  const normalizedWorkspace = workspaceArg?.trim();
+  if (workspaceArg !== void 0 && normalizedWorkspace?.length === 0) {
+    throw new PmCliError("--workspace must not be empty", EXIT_CODE.USAGE);
+  }
+  if (normalizedWorkspace !== void 0) {
+    if (global.path !== void 0 || isPathLikeInitTarget(prefixArg)) {
+      throw new PmCliError("--workspace cannot be combined with --pm-path/--path or a path-like positional target.", EXIT_CODE.USAGE);
+    }
+    const workspaceRoot = path8.resolve(cwd, normalizedWorkspace);
+    const pmRoot2 = path8.join(workspaceRoot, ".agents", "pm");
+    return {
+      pmRoot: pmRoot2,
+      prefixArg,
+      target: { mode: "workspace-path", tracker_root: pmRoot2, workspace_root: workspaceRoot }
+    };
+  }
   if (global.path === void 0 && isPathLikeInitTarget(prefixArg)) {
     const positionalTarget = path8.resolve(cwd, prefixArg.trim());
     return {
       pmRoot: positionalTarget,
       prefixArg: void 0,
-      positional_target: positionalTarget
+      target: { mode: "tracker-path", tracker_root: positionalTarget }
     };
   }
+  const pmRoot = resolvePmRoot(cwd, global.path);
   return {
-    pmRoot: resolvePmRoot(cwd, global.path),
-    prefixArg
+    pmRoot,
+    prefixArg,
+    target: global.path === void 0 ? { mode: "workspace-discovery", tracker_root: pmRoot, workspace_root: cwd } : { mode: "tracker-path", tracker_root: pmRoot }
   };
 }
 function normalizeInitAgentGuidanceMode(rawValue) {
@@ -6336,8 +6411,8 @@ async function isLikelyWorkspaceRoot(candidate) {
   }
   return false;
 }
-async function assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, global, force) {
-  if (global.path === void 0 || force) {
+async function assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, explicitTrackerTarget, force) {
+  if (!explicitTrackerTarget || force) {
     return;
   }
   if (await pathExists(path8.join(pmRoot, "settings.json"))) {
@@ -6350,7 +6425,7 @@ async function assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, global, force
   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.",
+    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",
@@ -6605,47 +6680,53 @@ async function ensureInitTypeDirectories(params) {
   params.createdDirs.push(...scaffold.createdDirs);
   params.warnings.push(...scaffold.warnings);
 }
-async function maybeInstallInitBundledPackages(installBundledPackages, global, warnings) {
+async function maybeInstallInitBundledPackages(installBundledPackages, global, pmRoot, warnings) {
   if (!installBundledPackages) {
     return void 0;
   }
-  const packageInstallResult = await runExtension("all", { install: true, project: true }, global);
+  const packageInstallResult = await runExtension("all", { install: true, project: true }, { ...global, path: pmRoot });
   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);
+  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: pm create --type Task --title "<title>"',
-    "List active items: pm list",
-    "Get agent-friendly project context: pm context"
+    `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: 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)");
+    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: pm cal, pm templates, pm guide");
+    nextSteps.push(`Explore newly-available commands: ${pmCommand(["cal"])}, ${pmCommand(["templates"])}, ${pmCommand(["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(`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) {
-    if (!nextSteps.includes(guidanceNextStep)) {
-      nextSteps.push(guidanceNextStep);
+    const scopedGuidance = params.target.mode === "workspace-discovery" ? guidanceNextStep : guidanceNextStep.replace(/\bpm (?=[a-z])/g, () => `${pmCommand([])} `);
+    if (!nextSteps.includes(scopedGuidance)) {
+      nextSteps.push(scopedGuidance);
     }
   }
   return nextSteps;
 }
 async function runInit(prefixArg, global, options = {}) {
   const cwd = process.cwd();
-  const invocation = resolveInitInvocation(cwd, global, prefixArg);
+  const invocation = resolveInitInvocation(cwd, global, prefixArg, options.workspace);
   const pmRoot = invocation.pmRoot;
   prefixArg = invocation.prefixArg;
-  await assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, global, options.force === true);
+  await assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, invocation.target.mode === "tracker-path", options.force === true);
   const createdDirs = [];
   const warnings = [];
   const baseDirs = await ensureInitDirectories(pmRoot, PM_REQUIRED_SUBDIRS);
@@ -6685,15 +6766,17 @@ async function runInit(prefixArg, global, options = {}) {
     settings = await readSettings(pmRoot);
   }
   await ensureInitTypeDirectories({ pmRoot, settings, createdDirs, warnings });
-  const installedPackages = await maybeInstallInitBundledPackages(normalizedOptions.installBundledPackages, global, warnings);
+  const installedPackages = await maybeInstallInitBundledPackages(normalizedOptions.installBundledPackages, global, pmRoot, warnings);
   const nextSteps = buildInitNextSteps({
     installBundledPackages: normalizedOptions.installBundledPackages,
     registeredTypePreset,
-    agentGuidanceNextSteps: agentGuidance.next_steps
+    agentGuidanceNextSteps: agentGuidance.next_steps,
+    target: invocation.target
   });
   return {
     ok: true,
     path: pmRoot,
+    target: invocation.target,
     settings,
     created_dirs: createdDirs,
     warnings,
@@ -6721,6 +6804,6 @@ export {
   summarizeInitResult,
   runInit
 };
-//# sourceMappingURL=chunk-GE44TQMC.js.map
+//# sourceMappingURL=chunk-CUBPPDDF.js.map
 
-//# debugId=dd6181c4-91c1-58ac-92c2-ce5ae31a5816
+//# debugId=704ef87f-4cbc-5841-bb42-d6cfb02586a7