gsd-pi 2.80.0-dev.b62439b9f → 2.80.0-dev.c5c38454b

package/dist/{cli/cli-web-branch.d.ts → cli-web-branch.d.ts}

@@ -35,7 +35,7 @@ export interface RunWebCliBranchDeps {
 }
 export declare function parseCliArgs(argv: string[]): CliFlags;
 export declare function buildHeadlessAutoArgs(flags: Pick<CliFlags, 'messages' | 'model'>): string[];
-export { getProjectSessionsDir } from '../app/project-sessions.js';
+export { getProjectSessionsDir } from './project-sessions.js';
 export declare function migrateLegacyFlatSessions(baseSessionsDir: string, projectSessionsDir: string): void;
 /**
  * Resolve the working directory for context-aware launch detection.

package/dist/{cli/cli-web-branch.js → cli-web-branch.js}

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync } from 'node:fs';
 import { join, resolve, sep } from 'node:path';
-import { agentDir as defaultAgentDir, sessionsDir as defaultSessionsDir, webPreferencesPath as defaultWebPreferencesPath } from '../app/app-paths.js';
-import { getProjectSessionsDir } from '../app/project-sessions.js';
+import { agentDir as defaultAgentDir, sessionsDir as defaultSessionsDir, webPreferencesPath as defaultWebPreferencesPath } from './app-paths.js';
+import { getProjectSessionsDir } from './project-sessions.js';
 import { launchWebMode, stopWebMode } from './web-mode.js';
 export function parseCliArgs(argv) {
     const flags = { extensions: [], messages: [] };
@@ -76,7 +76,7 @@ export function parseCliArgs(argv) {
 export function buildHeadlessAutoArgs(flags) {
     return flags.model ? ['--model', flags.model, ...flags.messages] : [...flags.messages];
 }
-export { getProjectSessionsDir } from '../app/project-sessions.js';
+export { getProjectSessionsDir } from './project-sessions.js';
 export function migrateLegacyFlatSessions(baseSessionsDir, projectSessionsDir) {
     if (!existsSync(baseSessionsDir))
         return;

package/dist/{cli/cli.js → cli.js}

@@ -1,24 +1,24 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { agentDir, sessionsDir, authFilePath } from '../app/app-paths.js';
-import { initResources, buildResourceLoader, getNewerManagedResourceVersion } from '../resource-runtime/resource-loader.js';
-import { ensureManagedTools } from '../app/tool-bootstrap.js';
-import { loadStoredEnvKeys } from '../onboarding/wizard.js';
-import { migratePiCredentials } from '../providers/pi-migration.js';
-import { shouldRunOnboarding, runOnboarding } from '../onboarding/onboarding.js';
+import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
+import { initResources, buildResourceLoader, getNewerManagedResourceVersion } from './resource-loader.js';
+import { ensureManagedTools } from './tool-bootstrap.js';
+import { loadStoredEnvKeys } from './wizard.js';
+import { migratePiCredentials } from './pi-migration.js';
+import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 import chalk from 'chalk';
-import { checkForUpdates } from '../update/update-check.js';
+import { checkForUpdates } from './update-check.js';
 import { shouldBypassManagedResourceMismatchGate } from './cli-policy.js';
 import { shouldRedirectAutoToHeadless } from './cli-auto-routing.js';
 import { printHelp, printSubcommandHelp } from './help-text.js';
-import { applySecurityOverrides } from '../security/security-overrides.js';
-import { validateConfiguredModel } from '../startup/startup-model-validation.js';
-import { migrateAnthropicDefaultToClaudeCode } from '../providers/provider-migrations.js';
+import { applySecurityOverrides } from './security-overrides.js';
+import { validateConfiguredModel } from './startup-model-validation.js';
+import { migrateAnthropicDefaultToClaudeCode } from './provider-migrations.js';
 import { buildHeadlessAutoArgs, parseCliArgs, runWebCliBranch, migrateLegacyFlatSessions, } from './cli-web-branch.js';
 import { stopWebMode } from './web-mode.js';
-import { getProjectSessionsDir } from '../app/project-sessions.js';
-import { markStartup, printStartupTimings } from '../startup/startup-timings.js';
-import { applyRtkProcessEnv, GSD_RTK_DISABLED_ENV, isTruthy } from '../rtk/rtk-shared.js';
+import { getProjectSessionsDir } from './project-sessions.js';
+import { markStartup, printStartupTimings } from './startup-timings.js';
+import { applyRtkProcessEnv, GSD_RTK_DISABLED_ENV, isTruthy } from './rtk-shared.js';
 let piCodingAgentModulePromise;
 function loadPiCodingAgentModule() {
     return (piCodingAgentModulePromise ??= import('@gsd/pi-coding-agent'));
@@ -139,7 +139,7 @@ async function doRtkBootstrap() {
     // Honor GSD_RTK_DISABLED if already explicitly set in the environment
     // (env var takes precedence over preferences for manual override).
     if (!rtkDisabled) {
-        const { loadEffectiveGSDPreferences } = await import('../resources/extensions/gsd/preferences.js');
+        const { loadEffectiveGSDPreferences } = await import('./resources/extensions/gsd/preferences.js');
         const prefs = loadEffectiveGSDPreferences();
         const rtkEnabled = prefs?.preferences.experimental?.rtk === true;
         if (!rtkEnabled) {
@@ -159,7 +159,7 @@ async function doRtkBootstrap() {
         };
     }
     else {
-        const { bootstrapRtk } = await import('../rtk/rtk.js');
+        const { bootstrapRtk } = await import('./rtk.js');
         rtkStatus = await bootstrapRtk();
     }
     markStartup('bootstrapRtk');
@@ -180,7 +180,7 @@ function ensureRtkBootstrap() {
 // command is blocked — only `update` should bypass the gate so the user can
 // actually upgrade out of the broken state. See shouldBypassManagedResourceMismatchGate.
 if (shouldBypassManagedResourceMismatchGate(cliFlags.messages[0])) {
-    const { runUpdate } = await import('../update/update-cmd.js');
+    const { runUpdate } = await import('./update-cmd.js');
     await runUpdate();
     process.exit(0);
 }
@@ -387,7 +387,7 @@ if (cliFlags.messages[0] === 'headless') {
     // headless-query loads from src/resources/ while auto/interactive load
     // from ~/.gsd/agent/extensions/ — different extension copies diverge.
     initResources(agentDir);
-    const { runHeadless, parseHeadlessArgs } = await import('../headless/headless.js');
+    const { runHeadless, parseHeadlessArgs } = await import('./headless.js');
     await runHeadless(parseHeadlessArgs(process.argv));
     process.exit(0);
 }
@@ -398,7 +398,7 @@ if (cliFlags.messages[0] === 'headless') {
  */
 async function runHeadlessFromAuto(headlessArgs) {
     await ensureRtkBootstrap();
-    const { runHeadless, parseHeadlessArgs } = await import('../headless/headless.js');
+    const { runHeadless, parseHeadlessArgs } = await import('./headless.js');
     const argv = [process.argv[0], process.argv[1], 'headless', ...headlessArgs];
     await runHeadless(parseHeadlessArgs(argv));
     process.exit(0);
@@ -422,7 +422,7 @@ if (shouldRedirectAutoToHeadless(cliFlags.messages[0], process.stdin.isTTY, proc
 if (!isPrintMode &&
     cliFlags.listModels === undefined &&
     (cliFlags.messages[0] === 'worktree' || cliFlags.messages[0] === 'wt')) {
-    const { handleList, handleMerge, handleClean, handleRemove } = await import('../worktrees/worktree-cli.js');
+    const { handleList, handleMerge, handleClean, handleRemove } = await import('./worktree-cli.js');
     const sub = cliFlags.messages[1];
     const subArgs = cliFlags.messages.slice(2);
     if (!sub || sub === 'list') {
@@ -455,7 +455,7 @@ markStartup('AuthStorage.create');
 loadStoredEnvKeys(authStorage);
 migratePiCredentials(authStorage);
 // Resolve models.json path with fallback to ~/.pi/agent/models.json
-const { resolveModelsJsonPath } = await import('../providers/models-resolver.js');
+const { resolveModelsJsonPath } = await import('./models-resolver.js');
 const modelsJsonPath = resolveModelsJsonPath();
 const modelRegistry = new ModelRegistry(authStorage, modelsJsonPath);
 markStartup('ModelRegistry');
@@ -614,7 +614,7 @@ if (isPrintMode) {
     }
     if (mode === 'mcp') {
         printStartupTimings();
-        const { startMcpServer } = await import('../mcp/mcp-server.js');
+        const { startMcpServer } = await import('./mcp-server.js');
         // Activate every registered tool before starting the MCP transport.
         // `session.agent.state.tools` is the *active* subset, not the full
         // registry — if we expose only the active set, extension-registered
@@ -642,7 +642,7 @@ if (isPrintMode) {
 // Worktree flag (-w) — create/resume a worktree for the interactive session
 // ---------------------------------------------------------------------------
 if (cliFlags.worktree) {
-    const { handleWorktreeFlag } = await import('../worktrees/worktree-cli.js');
+    const { handleWorktreeFlag } = await import('./worktree-cli.js');
     await handleWorktreeFlag(cliFlags.worktree);
 }
 // ---------------------------------------------------------------------------
@@ -650,7 +650,7 @@ if (cliFlags.worktree) {
 // ---------------------------------------------------------------------------
 if (!cliFlags.worktree && !isPrintMode) {
     try {
-        const { showWorktreeStatusBanner } = await import('../worktrees/worktree-status-banner.js');
+        const { showWorktreeStatusBanner } = await import('./worktree-status-banner.js');
         showWorktreeStatusBanner(process.cwd());
     }
     catch { /* non-fatal */ }
@@ -763,10 +763,10 @@ if (!process.stdin.isTTY || !process.stdout.isTTY) {
 // Welcome screen — shown on every fresh interactive session before TUI takes over.
 // Skip when the first-run banner was already printed in loader.ts (prevents double banner).
 if (!process.env.GSD_FIRST_RUN_BANNER) {
-    const { printWelcomeScreen } = await import('../onboarding/welcome-screen.js');
+    const { printWelcomeScreen } = await import('./welcome-screen.js');
     let remoteChannel;
     try {
-        const { resolveRemoteConfig } = await import('../resources/extensions/remote-questions/config.js');
+        const { resolveRemoteConfig } = await import('./resources/extensions/remote-questions/config.js');
         const rc = resolveRemoteConfig();
         if (rc)
             remoteChannel = rc.channel;

package/dist/{extension-runtime/extension-registry.js → extension-registry.js}

@@ -6,7 +6,7 @@
  * The only way an extension stops loading is an explicit `gsd extensions disable <id>`.
  */
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
-import { appRoot } from "../app/app-paths.js";
+import { appRoot } from "./app-paths.js";
 import { dirname, join } from "node:path";
 // ─── Validation ─────────────────────────────────────────────────────────────
 function isRegistry(data) {

package/dist/{headless/headless-query.d.ts → headless-query.d.ts}

@@ -13,7 +13,7 @@
  * We use createJiti() here because this module is imported directly from cli.ts,
  * bypassing the extension loader's jiti setup (#1137).
  */
-import type { GSDState } from '../resources/extensions/gsd/types.js';
+import type { GSDState } from './resources/extensions/gsd/types.js';
 /**
  * Resolve the GSD extensions root for headless-query. Prefers the synced
  * agent directory (so headless-query loads the same extension copy as

package/dist/{headless/headless-query.js → headless-query.js}

@@ -17,7 +17,7 @@ import { createJiti } from '@mariozechner/jiti';
 import { fileURLToPath } from 'node:url';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { resolveBundledGsdExtensionModule } from '../extension-runtime/bundled-resource-path.js';
+import { resolveBundledGsdExtensionModule } from './bundled-resource-path.js';
 const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
 const { existsSync } = await import('node:fs');
 /**
@@ -49,10 +49,9 @@ export function shouldUseAgentExtensionsDir(opts) {
 }
 const agentExtensionsDir = resolveGsdAgentExtensionsDir();
 const { useAgentDir } = shouldUseAgentExtensionsDir({ env: process.env });
-const bundledResourceImportUrl = new URL('../loader.js', import.meta.url).href;
 const gsdExtensionPath = (...segments) => useAgentDir
     ? resolveAgentExtensionModule(agentExtensionsDir, segments)
-    : resolveBundledGsdExtensionModule(bundledResourceImportUrl, segments.join('/'));
+    : resolveBundledGsdExtensionModule(import.meta.url, segments.join('/'));
 function resolveAgentExtensionModule(agentDir, segments) {
     const requested = join(agentDir, ...segments);
     if (existsSync(requested))

package/dist/{headless/headless-recover.js → headless-recover.js}

@@ -21,16 +21,15 @@
 import { createJiti } from '@mariozechner/jiti';
 import { fileURLToPath } from 'node:url';
 import { resolveGsdAgentExtensionsDir, shouldUseAgentExtensionsDir } from './headless-query.js';
-import { resolveBundledGsdExtensionModule } from '../extension-runtime/bundled-resource-path.js';
+import { resolveBundledGsdExtensionModule } from './bundled-resource-path.js';
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
 const agentExtensionsDir = resolveGsdAgentExtensionsDir();
 const { useAgentDir } = shouldUseAgentExtensionsDir({ env: process.env });
-const bundledResourceImportUrl = new URL('../loader.js', import.meta.url).href;
 const gsdExtensionPath = (...segments) => useAgentDir
     ? resolveAgentExtensionModule(agentExtensionsDir, segments)
-    : resolveBundledGsdExtensionModule(bundledResourceImportUrl, segments.join('/'));
+    : resolveBundledGsdExtensionModule(import.meta.url, segments.join('/'));
 function resolveAgentExtensionModule(agentDir, segments) {
     const requested = join(agentDir, ...segments);
     if (existsSync(requested))

package/dist/{headless/headless.js → headless.js}

@@ -15,7 +15,7 @@ import { existsSync, mkdirSync, writeFileSync, writeSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolve } from 'node:path';
 import { RpcClient, SessionManager } from '@gsd/pi-coding-agent';
-import { getProjectSessionsDir } from '../app/project-sessions.js';
+import { getProjectSessionsDir } from './project-sessions.js';
 import { loadAndValidateAnswerFile, AnswerInjector } from './headless-answers.js';
 import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotification, isQuickCommand, FIRE_AND_FORGET_METHODS, IDLE_TIMEOUT_MS, NEW_MILESTONE_IDLE_TIMEOUT_MS, isInteractiveHeadlessTool, shouldArmHeadlessIdleTimeout, EXIT_SUCCESS, EXIT_ERROR, EXIT_BLOCKED, EXIT_CANCELLED, mapStatusToExitCode, } from './headless-events.js';
 import { VALID_OUTPUT_FORMATS } from './headless-types.js';
@@ -280,8 +280,8 @@ async function runHeadlessOnce(options, restartCount) {
     // suite) get the same diagnostic without a TTY.
     if (options.command === 'doctor') {
         const wantsJson = options.json || options.commandArgs.includes('--json');
-        const { runGSDDoctor } = await import('../resources/extensions/gsd/doctor.js');
-        const { formatDoctorReport, formatDoctorReportJson } = await import('../resources/extensions/gsd/doctor-format.js');
+        const { runGSDDoctor } = await import('./resources/extensions/gsd/doctor.js');
+        const { formatDoctorReport, formatDoctorReportJson } = await import('./resources/extensions/gsd/doctor-format.js');
         let exitCode = 1;
         try {
             const report = await runGSDDoctor(process.cwd());

package/dist/loader.js

@@ -21,7 +21,7 @@ if (firstArg === '--version' || firstArg === '-v') {
     process.exit(0);
 }
 if (firstArg === '--help' || firstArg === '-h') {
-    const { printHelp } = await import('./cli/help-text.js');
+    const { printHelp } = await import('./help-text.js');
     printHelp(gsdVersion);
     process.exit(0);
 }
@@ -31,7 +31,7 @@ if (firstArg === '--help' || firstArg === '-h') {
 // package.json (already parsed above) and verifies git is available.
 // ---------------------------------------------------------------------------
 {
-    const { MIN_NODE_MAJOR, checkNodeVersion, requireGit } = await import('./startup/runtime-checks.js');
+    const { MIN_NODE_MAJOR, checkNodeVersion, requireGit } = await import('./runtime-checks.js');
     const red = '\x1b[31m';
     const bold = '\x1b[1m';
     const dim = '\x1b[2m';
@@ -57,13 +57,13 @@ if (firstArg === '--help' || firstArg === '-h') {
         process.exit(1);
     }
 }
-import { agentDir, appRoot } from './app/app-paths.js';
-import { applyRtkProcessEnv } from './rtk/rtk-shared.js';
-import { serializeBundledExtensionPaths } from './extension-runtime/bundled-extension-paths.js';
-import { resolveBundledResourcesDirFromPackageRoot } from './extension-runtime/bundled-resource-path.js';
-import { discoverExtensionEntryPaths } from './extension-runtime/extension-discovery.js';
-import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled } from './extension-runtime/extension-registry.js';
-import { renderLogo } from './cli/logo.js';
+import { agentDir, appRoot } from './app-paths.js';
+import { applyRtkProcessEnv } from './rtk-shared.js';
+import { serializeBundledExtensionPaths } from './bundled-extension-paths.js';
+import { resolveBundledResourcesDirFromPackageRoot } from './bundled-resource-path.js';
+import { discoverExtensionEntryPaths } from './extension-discovery.js';
+import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled } from './extension-registry.js';
+import { renderLogo } from './logo.js';
 // pkg/ is a shim directory: contains gsd's piConfig (package.json) and pi's
 // theme assets (dist/modes/interactive/theme/) without a src/ directory.
 // This allows config.js to:
@@ -235,4 +235,4 @@ if (missingPackages.length > 0) {
     process.exit(1);
 }
 // Dynamic import defers ESM evaluation — config.js will see PI_PACKAGE_DIR above
-await import('./cli/cli.js');
+await import('./cli.js');

package/dist/{providers/models-resolver.js → models-resolver.js}

@@ -11,7 +11,7 @@
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { agentDir } from '../app/app-paths.js';
+import { agentDir } from './app-paths.js';
 const GSD_MODELS_PATH = join(agentDir, 'models.json');
 const PI_MODELS_PATH = join(homedir(), '.pi', 'agent', 'models.json');
 /**

package/dist/{onboarding/onboarding.js → onboarding.js}

@@ -12,11 +12,11 @@
 import { execFile } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { renderLogo } from '../cli/logo.js';
-import { agentDir } from '../app/app-paths.js';
-import { isClaudeCliReady } from '../startup/claude-cli-check.js';
-import { markOnboardingComplete, markStepCompleted, markStepSkipped, isOnboardingComplete, } from '../resources/extensions/gsd/onboarding-state.js';
-import { getLlmProviderIds } from '../resources/extensions/gsd/setup-catalog.js';
+import { renderLogo } from './logo.js';
+import { agentDir } from './app-paths.js';
+import { isClaudeCliReady } from './claude-cli-check.js';
+import { markOnboardingComplete, markStepCompleted, markStepSkipped, isOnboardingComplete, } from './resources/extensions/gsd/onboarding-state.js';
+import { getLlmProviderIds } from './resources/extensions/gsd/setup-catalog.js';
 // ─── Constants ────────────────────────────────────────────────────────────────
 const TOOL_KEYS = [
     {
@@ -825,7 +825,7 @@ export async function runRemoteQuestionsStep(p, pc, authStorage) {
         });
         if (p.isCancel(channelId) || !channelId)
             return null;
-        const { saveRemoteQuestionsConfig } = await import('../providers/remote-questions-config.js');
+        const { saveRemoteQuestionsConfig } = await import('./remote-questions-config.js');
         saveRemoteQuestionsConfig('slack', channelId.trim());
         p.log.success(`Slack channel: ${pc.green(channelId.trim())}`);
         return 'Slack';
@@ -893,7 +893,7 @@ export async function runRemoteQuestionsStep(p, pc, authStorage) {
             ts.stop('Could not reach Telegram API');
             return null;
         }
-        const { saveRemoteQuestionsConfig } = await import('../providers/remote-questions-config.js');
+        const { saveRemoteQuestionsConfig } = await import('./remote-questions-config.js');
         saveRemoteQuestionsConfig('telegram', trimmedChatId);
         p.log.success(`Telegram chat: ${pc.green(trimmedChatId)}`);
         return 'Telegram';
@@ -1002,7 +1002,7 @@ async function runDiscordChannelStep(p, pc, token) {
         channelId = channelChoice;
     }
     // Save remote questions config
-    const { saveRemoteQuestionsConfig } = await import('../providers/remote-questions-config.js');
+    const { saveRemoteQuestionsConfig } = await import('./remote-questions-config.js');
     saveRemoteQuestionsConfig('discord', channelId);
     const channelName = channels.find(ch => ch.id === channelId)?.name;
     p.log.success(`Discord channel: ${pc.green(channelName ? `#${channelName}` : channelId)}`);

package/dist/{providers/remote-questions-config.js → remote-questions-config.js}

@@ -9,7 +9,7 @@
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { appRoot } from "../app/app-paths.js";
+import { appRoot } from "./app-paths.js";
 // Inlined from preferences.ts to avoid crossing the compiled/uncompiled
 // boundary — this file is compiled by tsc, but preferences.ts is loaded
 // via jiti at runtime. Importing it as .js fails because no .js exists

package/dist/{resource-runtime/resource-loader.d.ts → resource-loader.d.ts}

@@ -1,5 +1,5 @@
 import type { DefaultResourceLoader as DefaultResourceLoaderType } from '@gsd/pi-coding-agent';
-export { discoverExtensionEntryPaths } from '../extension-runtime/extension-discovery.js';
+export { discoverExtensionEntryPaths } from './extension-discovery.js';
 export declare function getExtensionKey(entryPath: string, extensionsDir: string): string;
 export declare function readManagedResourceVersion(agentDir: string): string | null;
 /**

package/dist/{resource-runtime/resource-loader.js → resource-loader.js}

@@ -3,10 +3,10 @@ import { homedir } from 'node:os';
 import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, openSync, closeSync, readFileSync, readlinkSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { compareSemver } from '../update/update-check.js';
-import { discoverExtensionEntryPaths } from '../extension-runtime/extension-discovery.js';
-import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled, ensureRegistryEntries } from '../extension-runtime/extension-registry.js';
-import { resolveBundledResourcesDirFromPackageRoot } from '../extension-runtime/bundled-resource-path.js';
+import { compareSemver } from './update-check.js';
+import { discoverExtensionEntryPaths } from './extension-discovery.js';
+import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled, ensureRegistryEntries } from './extension-registry.js';
+import { resolveBundledResourcesDirFromPackageRoot } from './bundled-resource-path.js';
 let piCodingAgentModulePromise;
 function loadPiCodingAgentModule() {
     return (piCodingAgentModulePromise ??= import('@gsd/pi-coding-agent'));
@@ -19,12 +19,12 @@ function loadPiCodingAgentModule() {
 // that use gsd — causing stale/broken extensions to be synced to ~/.gsd/agent/.
 // dist/resources/ is populated by the build step (`npm run copy-resources`) and
 // reflects the built state, not the currently checked-out branch.
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const resourcesDir = resolveBundledResourcesDirFromPackageRoot(packageRoot);
 const bundledExtensionsDir = join(resourcesDir, 'extensions');
 const resourceVersionManifestName = 'managed-resources.json';
 const resourceFingerprintFileName = '.managed-resources-content-hash';
-export { discoverExtensionEntryPaths } from '../extension-runtime/extension-discovery.js';
+export { discoverExtensionEntryPaths } from './extension-discovery.js';
 export function getExtensionKey(entryPath, extensionsDir) {
     const relPath = relative(extensionsDir, entryPath);
     return relPath.split(/[\\/]/)[0].replace(/\.(?:ts|js)$/, '');

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-052bf7f2ece6ee3b
+7088672cce649c64

package/dist/resources/extensions/github-sync/templates.js

@@ -8,6 +8,37 @@
  * for the `gh` CLI body parameters.
  */
 import { buildPrEvidence } from "../gsd/pr-evidence.js";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+/**
+ * Wrap a string in a CommonMark inline-code span, escaping any embedded
+ * backticks by selecting a fence longer than the longest backtick run inside
+ * the input. If the input begins or ends with a backtick, pad with a single
+ * space inside the fence (CommonMark requirement).
+ *
+ * Empty input returns an empty string (no fence) — there is nothing to render
+ * as code, and emitting an empty pair of backticks would produce literal
+ * backticks in GitHub-flavored markdown.
+ */
+export function inlineCode(s) {
+    if (s.length === 0)
+        return "";
+    let longestRun = 0;
+    let currentRun = 0;
+    for (const ch of s) {
+        if (ch === "`") {
+            currentRun++;
+            if (currentRun > longestRun)
+                longestRun = currentRun;
+        }
+        else {
+            currentRun = 0;
+        }
+    }
+    const fence = "`".repeat(longestRun + 1);
+    const needsPad = s.startsWith("`") || s.endsWith("`");
+    const pad = needsPad ? " " : "";
+    return `${fence}${pad}${s}${pad}${fence}`;
+}
 export function formatMilestoneIssueBody(data) {
     const lines = [];
     lines.push(`# ${data.id}: ${data.title}`);
@@ -78,7 +109,7 @@ export function formatTaskIssueBody(data) {
     if (data.files?.length) {
         lines.push("### Files");
         for (const file of data.files) {
-            lines.push(`- \`${file}\``);
+            lines.push(`- ${inlineCode(file)}`);
         }
         lines.push("");
     }
@@ -132,15 +163,14 @@ export function formatSwarmLanePRBody(data) {
     const summaries = [
         [
             "### Swarm lane",
-            `**Lane:** \`${laneLabel}\``,
-            `**Branch:** \`${data.lane.branch}\``,
+            `**Lane:** ${inlineCode(laneLabel)}`,
+            `**Branch:** ${inlineCode(data.lane.branch)}`,
             data.lane.owner ? `**Owner:** ${data.lane.owner}` : "",
-            data.lane.latestCommit ? `**Latest commit:** \`${data.lane.latestCommit}\`` : "",
+            data.lane.latestCommit ? `**Latest commit:** ${inlineCode(data.lane.latestCommit)}` : "",
         ].filter(Boolean).join("\n"),
         `### Impact area\n${data.impactArea}`,
         `### Changed contracts\n${checkedList(data.lane.changedContracts, "No shared contracts changed").join("\n")}`,
         `### Transition risks\n${checkedList(data.transitionRisks, "No transition risks identified").join("\n")}`,
-        data.lane.blockers?.length ? `### Blockers\n${data.lane.blockers.map((blocker) => `- ${blocker}`).join("\n")}` : "",
     ].filter(Boolean);
     return buildPrEvidence({
         milestoneId: laneLabel,
@@ -150,6 +180,7 @@ export function formatSwarmLanePRBody(data) {
         changeType: "refactor",
         linkedIssue: data.linkedIssue ? `Closes #${data.linkedIssue}` : undefined,
         summaries,
+        blockers: data.lane.blockers ?? [],
         testsRun: data.lane.testEvidence,
         rollbackNotes: data.rollbackPlan,
         how: "Generated by GSD GitHub Sync swarm routines from lane evidence.",
@@ -159,7 +190,7 @@ export function formatSwarmReleaseChecklistBody(data) {
     const lines = [];
     lines.push(`# UOK Swarm Release Checklist`);
     lines.push("");
-    lines.push(`**Integration branch:** \`${data.integrationBranch}\``);
+    lines.push(`**Integration branch:** ${inlineCode(data.integrationBranch)}`);
     lines.push("");
     lines.push("## Lane summary");
     lines.push("");
@@ -167,9 +198,9 @@ export function formatSwarmReleaseChecklistBody(data) {
     lines.push("|------|--------|-------|--------|--------|");
     for (const lane of data.lanes) {
         const owner = lane.owner ?? "";
-        const commit = lane.latestCommit ? `\`${lane.latestCommit}\`` : "";
+        const commit = lane.latestCommit ? inlineCode(lane.latestCommit) : "";
         const status = lane.blockers?.length ? "blocked" : "ready";
-        lines.push(`| \`${SWARM_LANE_LABELS[lane.id]}\` | \`${lane.branch}\` | ${owner} | ${commit} | ${status} |`);
+        lines.push(`| ${inlineCode(SWARM_LANE_LABELS[lane.id])} | ${inlineCode(lane.branch)} | ${owner} | ${commit} | ${status} |`);
     }
     lines.push("");
     lines.push("## Required evidence");

package/dist/resources/extensions/gsd/auto/loop.js

@@ -268,6 +268,19 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             // ── Blanket try/catch: one bad iteration must not kill the session
             const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
             const uokFlags = resolveUokFlags(prefs);
+            // ── Check sidecar queue before deriveState ──
+            // NOTE: Sidecar dequeue MUST run before validateWorkflowSessionLock so a
+            // queued item is popped (and the `sidecar-dequeue` journal event emitted)
+            // even when the session lock invalidates this iteration. Inverting this
+            // order silently drops queued items on lock-loss. Refs #5308.
+            const sidecarItem = await dequeueSidecarItem({
+                queue: s.sidecarQueue,
+                executionGraphEnabled: uokFlags.executionGraph,
+                scheduleQueue: scheduleSidecarQueue,
+                warnSchedulingFailure: message => logWarning("dispatch", `sidecar queue scheduling failed: ${message}`),
+                logDequeue: payload => debugLog("autoLoop", { phase: "sidecar-dequeue", ...payload }),
+                emitDequeue: payload => journalReporter.emit("sidecar-dequeue", payload),
+            });
             const sessionLockOutcome = validateWorkflowSessionLock({
                 active: s.active,
                 iteration,
@@ -290,15 +303,6 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 finishTurn("stopped", "manual-attention", sessionLockOutcome.reason);
                 break;
             }
-            // ── Check sidecar queue before deriveState ──
-            const sidecarItem = await dequeueSidecarItem({
-                queue: s.sidecarQueue,
-                executionGraphEnabled: uokFlags.executionGraph,
-                scheduleQueue: scheduleSidecarQueue,
-                warnSchedulingFailure: message => logWarning("dispatch", `sidecar queue scheduling failed: ${message}`),
-                logDequeue: payload => debugLog("autoLoop", { phase: "sidecar-dequeue", ...payload }),
-                emitDequeue: payload => journalReporter.emit("sidecar-dequeue", payload),
-            });
             const ic = { ctx, pi, s, deps, prefs, iteration, flowId, nextSeq };
             journalReporter.emit("iteration-start", { iteration });
             let iterData;

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -1,14 +1,11 @@
-/**
- * auto/run-unit.ts — Single unit execution: session create → prompt → await agent_end.
- *
- * Imports from: auto/types, auto/resolve
- */
+// GSD-2 + src/resources/extensions/gsd/auto/run-unit.ts - Runs one GSD auto-mode unit from session creation through agent completion.
 import { NEW_SESSION_TIMEOUT_MS } from "./session.js";
 import { _clearCurrentResolve, _setCurrentResolve, _setSessionSwitchInFlight } from "./resolve.js";
 import { getCurrentTurnGeneration, runWithTurnGeneration, } from "./turn-epoch.js";
 import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
+import { formatAutoUnitWorkingMessage } from "../working-output-messages.js";
 // Tracks the latest session-switch attempt so a late timeout settlement from an
 // older runUnit() call cannot clear the guard for a newer one.
 let sessionSwitchGeneration = 0;
@@ -151,22 +148,29 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     // ── Send the prompt ──
     debugLog("runUnit", { phase: "send-message", unitType, unitId });
     const requestDispatchedAt = Date.now();
-    pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
+    ctx.ui.setWorkingMessage?.(formatAutoUnitWorkingMessage(unitType, unitId));
     // ── Await agent_end with absolute timeout (H4 fix) ──
     // If supervision fails to resolve unitPromise within 30s, treat as cancelled.
     // Without this, a crashed agent that never emits agent_end hangs the loop (#3161).
-    debugLog("runUnit", { phase: "awaiting-agent-end", unitType, unitId });
     const supervisor = resolveAutoSupervisorConfig();
     const UNIT_HARD_TIMEOUT_MS = Math.max(30_000, ((supervisor.hard_timeout_minutes ?? 30) * 60 * 1000) + 30_000);
     let unitTimeoutHandle;
-    const timeoutResult = new Promise((resolve) => {
-        unitTimeoutHandle = setTimeout(() => {
-            resolve({ status: "cancelled", errorContext: { message: "Unit hard timeout — supervision may have failed", category: "timeout", isTransient: true } });
-        }, UNIT_HARD_TIMEOUT_MS);
-    });
-    const result = await runWithTurnGeneration(capturedTurnGen, () => Promise.race([unitPromise, timeoutResult]));
-    if (unitTimeoutHandle)
-        clearTimeout(unitTimeoutHandle);
+    let result;
+    try {
+        pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
+        debugLog("runUnit", { phase: "awaiting-agent-end", unitType, unitId });
+        const timeoutResult = new Promise((resolve) => {
+            unitTimeoutHandle = setTimeout(() => {
+                resolve({ status: "cancelled", errorContext: { message: "Unit hard timeout — supervision may have failed", category: "timeout", isTransient: true } });
+            }, UNIT_HARD_TIMEOUT_MS);
+        });
+        result = await runWithTurnGeneration(capturedTurnGen, () => Promise.race([unitPromise, timeoutResult]));
+    }
+    finally {
+        if (unitTimeoutHandle)
+            clearTimeout(unitTimeoutHandle);
+        ctx.ui.setWorkingMessage?.(undefined);
+    }
     debugLog("runUnit", {
         phase: "agent-end-received",
         unitType,