lsd-pi 1.1.8 → 1.1.10

package/dist/headless.d.ts

@@ -33,6 +33,7 @@ export interface HeadlessOptions {
     eventFilter?: Set<string>;
     resumeSession?: string;
     bare?: boolean;
+    noSession?: boolean;
 }
 export interface ResumeSessionResult {
     session?: SessionInfo;

package/dist/headless.js

@@ -145,6 +145,9 @@ export function parseHeadlessArgs(argv) {
             else if (arg === '--bare') {
                 options.bare = true;
             }
+            else if (arg === '--no-session') {
+                options.noSession = true;
+            }
         }
         else if (options.command === 'auto') {
             options.command = arg;
@@ -297,9 +300,14 @@ async function runHeadlessOnce(options, restartCount) {
     }
     // Signal headless mode to the GSD extension (skips UAT human pause, etc.)
     clientOptions.env = { ...(clientOptions.env || {}), GSD_HEADLESS: '1' };
-    // Propagate --bare to the child process
-    if (options.bare) {
-        clientOptions.args = [...(clientOptions.args || []), '--bare'];
+    // Propagate headless session/context flags to the RPC child process.
+    const childArgs = [];
+    if (options.bare)
+        childArgs.push('--bare');
+    if (options.noSession)
+        childArgs.push('--no-session');
+    if (childArgs.length > 0) {
+        clientOptions.args = [...(clientOptions.args || []), ...childArgs];
     }
     const client = new RpcClient(clientOptions);
     // Event tracking

package/dist/help-text.js

@@ -91,6 +91,7 @@ const SUBCOMMAND_HELP = {
         '  --json                 JSONL event stream to stdout (alias for --output-format stream-json)',
         '  --output-format <fmt>  Output format: text (default), json (structured result), stream-json (JSONL events)',
         '  --bare                 Minimal context: skip lsd.md, CLAUDE.md, AGENTS.md, user settings, user skills',
+        '  --no-session           Disable session persistence for this headless run',
         '  --resume <id>          Resume a prior headless session by ID',
         '  --model ID             Override model',
         '  --supervised           Forward interactive UI requests to orchestrator via stdout/stdin',

package/dist/remote-questions-config.js

@@ -17,15 +17,21 @@ import { appRoot } from "./app-paths.js";
 const GLOBAL_PREFERENCES_PATH = join(appRoot, "PREFERENCES.md");
 export function saveRemoteQuestionsConfig(channel, channelId) {
     const prefsPath = GLOBAL_PREFERENCES_PATH;
-    const block = [
+    const content = existsSync(prefsPath) ? readFileSync(prefsPath, "utf-8") : "";
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    const existingRemoteBlock = fmMatch?.[1].match(/remote_questions:[\s\S]*?(?=\n[a-zA-Z_]|\n---|$)/)?.[0] ?? "";
+    const existingAutoConnect = existingRemoteBlock.match(/\n\s*telegram_live_relay_auto_connect:\s*(true|false)\s*$/m)?.[1];
+    const blockLines = [
         "remote_questions:",
         `  channel: ${channel}`,
         `  channel_id: "${channelId}"`,
         "  timeout_minutes: 5",
         "  poll_interval_seconds: 5",
-    ].join("\n");
-    const content = existsSync(prefsPath) ? readFileSync(prefsPath, "utf-8") : "";
-    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    ];
+    if (existingAutoConnect) {
+        blockLines.push(`  telegram_live_relay_auto_connect: ${existingAutoConnect}`);
+    }
+    const block = blockLines.join("\n");
     let next = content;
     if (fmMatch) {
         let frontmatter = fmMatch[1];

package/dist/resources/agents/scout.md

@@ -21,6 +21,7 @@ Strategy:
 2. Read key sections (not entire files) — use lsp to pinpoint exact locations first
 3. Identify types, interfaces, key functions
 4. Note dependencies between files
+5. Optimize for useful handoff quality, not brevity alone — be as detailed as needed for the next agent to work without re-discovering the same context
 
 Output format:
 

package/dist/resources/extensions/ask-user-questions.js

@@ -12,6 +12,7 @@ import { sanitizeError } from "./shared/sanitize.js";
 import { Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { showInterviewRound, } from "./shared/tui.js";
+import { isTelegramLiveRelayConnected } from "./remote-questions/telegram-live-relay.js";
 // ─── Schema ───────────────────────────────────────────────────────────────────
 const OptionSchema = Type.Object({
     label: Type.String({ description: "User-facing label (1-5 words)" }),
@@ -86,7 +87,8 @@ export default function AskUserQuestions(pi) {
                 return errorResult("Error: UI not available (non-interactive mode)", params.questions);
             }
             // Delegate to shared interview UI
-            const result = await showInterviewRound(params.questions, {}, ctx);
+            const preferSequentialPrompts = isTelegramLiveRelayConnected();
+            const result = preferSequentialPrompts ? undefined : await showInterviewRound(params.questions, {}, ctx);
             // RPC mode fallback: custom() returns undefined, so showInterviewRound
             // may return undefined. Fall back to sequential ctx.ui.select() calls.
             if (!result) {

package/dist/resources/extensions/bg-shell/bg-shell-command.js

@@ -49,7 +49,7 @@ export function registerBgShellCommand(pi, state) {
                     ctx.ui.notify(lines.join("\n"), "info");
                     return;
                 }
-                await ctx.ui.custom((tui, theme, _kb, done) => {
+                const overlayResult = await ctx.ui.custom((tui, theme, _kb, done) => {
                     return new BgManagerOverlay(tui, theme, () => {
                         done();
                         state.refreshWidget();
@@ -63,6 +63,17 @@ export function registerBgShellCommand(pi, state) {
                         anchor: "center",
                     },
                 });
+                if (overlayResult === undefined || overlayResult === null) {
+                    const lines = Array.from(processes.values()).map(p => {
+                        const statusIcon = p.alive
+                            ? (p.status === "ready" ? "✓" : p.status === "error" ? "✗" : "⋯")
+                            : "○";
+                        const uptime = formatUptime(Date.now() - p.startedAt);
+                        const portInfo = p.ports.length > 0 ? ` :${p.ports.join(",")}` : "";
+                        return `${p.id}  ${statusIcon} ${p.status}  ${uptime}  ${p.label}  [${p.processType}]${portInfo}`;
+                    });
+                    ctx.ui.notify(lines.join("\n"), "info");
+                }
                 return;
             }
             if (sub === "output" || sub === "digest") {
@@ -87,7 +98,7 @@ export function registerBgShellCommand(pi, state) {
                     }
                     return;
                 }
-                await ctx.ui.custom((tui, theme, _kb, done) => {
+                const overlayResult = await ctx.ui.custom((tui, theme, _kb, done) => {
                     const overlay = new BgManagerOverlay(tui, theme, () => {
                         done();
                         state.refreshWidget();
@@ -106,6 +117,16 @@ export function registerBgShellCommand(pi, state) {
                         anchor: "center",
                     },
                 });
+                if (overlayResult === undefined || overlayResult === null) {
+                    if (sub === "digest") {
+                        const digest = generateDigest(bg);
+                        ctx.ui.notify(formatDigestText(bg, digest), "info");
+                    }
+                    else {
+                        const output = getOutput(bg, { stream: "both", tail: 50 });
+                        ctx.ui.notify(output || "(no output)", "info");
+                    }
+                }
                 return;
             }
             if (sub === "kill") {
@@ -163,7 +184,7 @@ export function registerBgShellCommand(pi, state) {
         description: shortcutDesc("Open background process manager", "/bg"),
         handler: async (ctx) => {
             state.latestCtx = ctx;
-            await ctx.ui.custom((tui, theme, _kb, done) => {
+            const overlayResult = await ctx.ui.custom((tui, theme, _kb, done) => {
                 return new BgManagerOverlay(tui, theme, () => {
                     done();
                     state.refreshWidget();
@@ -177,6 +198,9 @@ export function registerBgShellCommand(pi, state) {
                     anchor: "center",
                 },
             });
+            if (overlayResult === undefined || overlayResult === null) {
+                ctx.ui.notify("Background manager overlay is unavailable in this UI. Use /bg list or /bg output <id>.", "info");
+            }
         },
     });
 }

package/dist/resources/extensions/get-secrets-from-user.js

@@ -86,7 +86,7 @@ export function detectDestination(basePath) {
 async function collectOneSecret(ctx, pageIndex, totalPages, keyName, hint, guidance) {
     if (!ctx.hasUI)
         return null;
-    return ctx.ui.custom((tui, theme, _kb, done) => {
+    const result = await ctx.ui.custom((tui, theme, _kb, done) => {
         let value = "";
         let cachedLines;
         const editorTheme = {
@@ -171,6 +171,11 @@ async function collectOneSecret(ctx, pageIndex, totalPages, keyName, hint, guida
             handleInput,
         };
     });
+    if (result !== undefined) {
+        return result;
+    }
+    ctx.ui.notify(`Secure input UI unavailable for ${keyName}; skipping to avoid plaintext secret entry.`, "warning");
+    return null;
 }
 /**
  * Exported wrapper around collectOneSecret for testing.
@@ -192,11 +197,11 @@ export async function showSecretsSummary(ctx, entries, existingKeys) {
     if (!ctx.hasUI)
         return;
     const existingSet = new Set(existingKeys);
-    await ctx.ui.custom((_tui, theme, _kb, done) => {
+    const result = await ctx.ui.custom((_tui, theme, _kb, done) => {
         let cachedLines;
         function handleInput(_data) {
-            // Any key dismisses — pass null to satisfy the typed done() callback
-            done(null);
+            // Any key dismisses. Return true to mark the custom UI as handled.
+            done(true);
         }
         function render(width) {
             if (cachedLines)
@@ -239,6 +244,21 @@ export async function showSecretsSummary(ctx, entries, existingKeys) {
             handleInput,
         };
     });
+    if (result === true) {
+        return;
+    }
+    const lines = ["Secrets Summary"];
+    for (const entry of entries) {
+        if (existingSet.has(entry.key))
+            lines.push(`✓ ${entry.key} (already set)`);
+        else if (entry.status === "collected")
+            lines.push(`✓ ${entry.key}`);
+        else if (entry.status === "skipped")
+            lines.push(`• ${entry.key} (skipped)`);
+        else
+            lines.push(`○ ${entry.key} (pending)`);
+    }
+    ctx.ui.notify(lines.join("\n"), "info");
 }
 // ─── Destination Write Helper ─────────────────────────────────────────────────
 /**

package/dist/resources/extensions/memory/auto-extract.js

@@ -127,6 +127,8 @@ This directory already exists — write files directly.
 Rules:
 - Save ONLY: user preferences/role, feedback/corrections, project context (deadlines, decisions), external references
 - Do NOT save: raw code snippets, low-level implementation details, file paths, git history, one-off debugging steps, ephemeral task details
+- This is extraction, not planning: do NOT create plans, TODO lists, or strategy docs
+- Never write under .lsd/plan/ or .gsd/plan/
 - Check existing memories below — update existing files rather than creating duplicates
 - Use frontmatter: ---\\nname: ...\\ndescription: ...\\ntype: user|feedback|project|reference\\n---
 - After writing topic files, update MEMORY.md with one-line index entries
@@ -321,12 +323,18 @@ const bundledPaths = Array.from(
       .flatMap((value) => String(value).split(delimiter).map((entry) => entry.trim()).filter(Boolean))
       // Explicitly disable cache-timer extension for auto-memory workers.
       // It is noisy in headless logs and provides no value for maintenance runs.
-      .filter((entry) => !/[\\/]cache-timer[\\/]/i.test(entry)),
+      .filter((entry) => !/[\\/]cache-timer[\\/]/i.test(entry))
+      // Also disable slash-commands: memory extraction workers should never
+      // enter /plan workflows or run approval orchestration.
+      .filter((entry) => !/[\\/]slash-commands[\\/]/i.test(entry)),
   ),
 );
 for (const extensionPath of bundledPaths) childArgs.push('--extension', extensionPath);
 if (model) childArgs.push('--model', model);
-childArgs.push('--bare', '--context', tmpPromptPath, '--context-text', instruction);
+// Auto-memory workers should never create normal session files.
+// Otherwise they pollute recents/session history for the project and can make
+// it look like new sessions started on the budget memory model.
+childArgs.push('--no-session', '--bare', '--context', tmpPromptPath, '--context-text', instruction);
 
 const child = spawn(
   process.execPath,
@@ -438,7 +446,7 @@ export function extractMemories(ctx, cwd) {
         `budgetModel: ${budgetModel ?? 'default'}`,
         `logPath: ${logPath}`,
     ].join('\n') + '\n', 'utf-8');
-    const instruction = 'Extract memories from the transcript above. Write any worth-saving memories to the memory directory, then update MEMORY.md.';
+    const instruction = 'Extract memories from the transcript above. Save only durable memories into the memory directory and update MEMORY.md. Do not create plan artifacts.';
     const helperScript = buildAutoExtractHelperScript();
     const proc = spawn(process.execPath, [
         '-e',