edsger 0.76.0 → 0.78.0

package/dist/commands/run-sheet/index.js

@@ -1,48 +0,0 @@
-import { runRunSheet, } from '../../phases/run-sheet/index.js';
-import { deregisterSession, registerSession, } from '../../system/session-manager.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { validateConfiguration } from '../../utils/validation.js';
-export const runRunSheetCommand = async (options) => {
-    const { releaseId } = options;
-    if (!releaseId) {
-        throw new Error('Release ID is required for run-sheet');
-    }
-    validateConfiguration({ verbose: options.verbose });
-    await registerSession({ command: 'run-sheet' });
-    logInfo(`Starting run sheet generation for release: ${releaseId}`);
-    try {
-        const result = await runRunSheet({
-            releaseId,
-            force: options.force,
-            verbose: options.verbose,
-        });
-        if (result.status === 'error') {
-            logError(`Run sheet generation failed: ${result.summary}`);
-            process.exitCode = 1;
-            return;
-        }
-        if (result.status === 'cached') {
-            logInfo(`Run sheet unchanged for ${result.releaseTag} — skipped clone.`);
-        }
-        else if (result.isDraft) {
-            logInfo(`Generated DRAFT run sheet for ${result.releaseTag} (tag not yet cut; used default branch).`);
-        }
-        else {
-            logInfo(`Generated run sheet for ${result.releaseTag}`);
-        }
-        if (result.cloneError) {
-            logInfo(`Clone warning: ${result.cloneError}`);
-        }
-        if (typeof result.agentTurns === 'number') {
-            logInfo(`Agent used ${result.agentTurns} turn(s)${result.model ? ` on model ${result.model}` : ''}.`);
-        }
-        logInfo('View it in the Release detail page of your product dashboard.');
-    }
-    catch (error) {
-        logError(`Run sheet generation failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exitCode = 1;
-    }
-    finally {
-        await deregisterSession();
-    }
-};

package/dist/commands/screen-flow/index.d.ts

@@ -1,18 +0,0 @@
-/**
- * CLI command: edsger screen-flow <productId> --diagram-id <id>
- *
- * Maps the product's user-facing screens and transitions into a structured
- * flow stored in diagrams / diagram_nodes / diagram_edges (rows tagged type='screen').
- *
- * The desktop UI creates a pending diagrams row first, then invokes the CLI
- * with --diagram-id; the CLI flips status running → success/failed and
- * populates the nodes/edges tables.
- */
-export interface ScreenFlowCliOptions {
-    diagramId: string;
-    /** Repo-only mode: generate against a single repositories row, no product. */
-    repoId?: string;
-    guidance?: string;
-    verbose?: boolean;
-}
-export declare function runScreenFlow(productId: string | undefined, options: ScreenFlowCliOptions): Promise<void>;

package/dist/commands/screen-flow/index.js

@@ -1,54 +0,0 @@
-/**
- * CLI command: edsger screen-flow <productId> --diagram-id <id>
- *
- * Maps the product's user-facing screens and transitions into a structured
- * flow stored in diagrams / diagram_nodes / diagram_edges (rows tagged type='screen').
- *
- * The desktop UI creates a pending diagrams row first, then invokes the CLI
- * with --diagram-id; the CLI flips status running → success/failed and
- * populates the nodes/edges tables.
- */
-import { runScreenFlowPhase } from '../../phases/screen-flow/index.js';
-import { deregisterSession, registerSession, } from '../../system/session-manager.js';
-import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-export async function runScreenFlow(productId, options) {
-    const { diagramId, repoId, guidance, verbose } = options;
-    if (!productId && !repoId) {
-        throw new Error('Either a product ID or --repo-id is required for screen-flow');
-    }
-    if (!diagramId) {
-        throw new Error('--diagram-id is required (the pending diagrams row id)');
-    }
-    await registerSession({
-        command: 'screen-flow',
-        ...(productId ? { productId } : {}),
-    });
-    if (productId) {
-        logInfo(`Starting screen flow generation for product ${productId}`);
-    }
-    else {
-        logInfo(`Starting screen flow generation for repository ${repoId}`);
-    }
-    try {
-        const result = await runScreenFlowPhase({
-            productId,
-            repoId,
-            diagramId,
-            guidance,
-            verbose,
-        });
-        if (result.status === 'success') {
-            logSuccess(result.message);
-            if (result.summary) {
-                logInfo(`\nSummary: ${result.summary}`);
-            }
-        }
-        else {
-            logError(result.message);
-            process.exit(1);
-        }
-    }
-    finally {
-        await deregisterSession();
-    }
-}

package/dist/commands/sequence-diagram/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * CLI command: edsger sequence-diagram <productId> --diagram-id <id>
- *
- * Traces one scenario through the product's code and maps the participants
- * and the ordered messages between them into a structured flow stored in
- * diagrams / diagram_nodes / diagram_edges (rows tagged type='sequence').
- *
- * The desktop UI creates a pending diagrams row first, then invokes the CLI
- * with --diagram-id; the CLI flips status running → success/failed and
- * populates the nodes/edges tables.
- */
-export interface SequenceDiagramCliOptions {
-    diagramId: string;
-    /** Repo-only mode: generate against a single repositories row, no product. */
-    repoId?: string;
-    guidance?: string;
-    verbose?: boolean;
-}
-export declare function runSequenceDiagram(productId: string | undefined, options: SequenceDiagramCliOptions): Promise<void>;

package/dist/commands/sequence-diagram/index.js

@@ -1,55 +0,0 @@
-/**
- * CLI command: edsger sequence-diagram <productId> --diagram-id <id>
- *
- * Traces one scenario through the product's code and maps the participants
- * and the ordered messages between them into a structured flow stored in
- * diagrams / diagram_nodes / diagram_edges (rows tagged type='sequence').
- *
- * The desktop UI creates a pending diagrams row first, then invokes the CLI
- * with --diagram-id; the CLI flips status running → success/failed and
- * populates the nodes/edges tables.
- */
-import { runSequenceDiagramPhase } from '../../phases/sequence-diagram/index.js';
-import { deregisterSession, registerSession, } from '../../system/session-manager.js';
-import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-export async function runSequenceDiagram(productId, options) {
-    const { diagramId, repoId, guidance, verbose } = options;
-    if (!productId && !repoId) {
-        throw new Error('Either a product ID or --repo-id is required for sequence-diagram');
-    }
-    if (!diagramId) {
-        throw new Error('--diagram-id is required (the pending diagrams row id)');
-    }
-    await registerSession({
-        command: 'sequence-diagram',
-        ...(productId ? { productId } : {}),
-    });
-    if (productId) {
-        logInfo(`Starting sequence diagram generation for product ${productId}`);
-    }
-    else {
-        logInfo(`Starting sequence diagram generation for repository ${repoId}`);
-    }
-    try {
-        const result = await runSequenceDiagramPhase({
-            productId,
-            repoId,
-            diagramId,
-            guidance,
-            verbose,
-        });
-        if (result.status === 'success') {
-            logSuccess(result.message);
-            if (result.summary) {
-                logInfo(`\nSummary: ${result.summary}`);
-            }
-        }
-        else {
-            logError(result.message);
-            process.exit(1);
-        }
-    }
-    finally {
-        await deregisterSession();
-    }
-}

package/dist/commands/session-serve/index.d.ts

@@ -1,32 +0,0 @@
-/**
- * `edsger session-serve <channelId>` — long-lived conversational agent for one
- * chat session.
- *
- * Where `session-turn` runs a single turn and exits, `session-serve` prepares
- * the session context once (repo clone, MCP toolbelt, system prompt) and then
- * stays alive, running one turn per command it reads from stdin. The SDK
- * session id is kept in memory and carried into the next turn automatically, so
- * the conversation (and prompt cache) stays warm without a per-turn cold start.
- *
- * Protocol — one JSON object per line on stdin:
- *   {"type":"turn"}                                  process pending messages
- *   {"type":"run-finished","runId":"…","command":"…"} report a finished cli_* run
- *   {"type":"shutdown"}                               drain + exit cleanly
- *
- * Turns run strictly one at a time (a session never has two turns in flight).
- * When stdin closes, the process exits after the current turn drains. Markers
- * (session id, background cli runs) are written to stdout exactly as the
- * one-shot command emits them, so the desktop's existing parsing is unchanged.
- */
-import { type SessionTurnCliOptions } from '../session-turn/index.js';
-/**
- * Emitted once the session context is built and the process is ready to accept
- * turn commands on stdin. The desktop may use it to know the daemon is live;
- * it is harmless to ignore.
- */
-export declare const SESSION_READY_MARKER = "__EDSGER_SESSION_READY__";
-export type SessionServeCliOptions = Omit<SessionTurnCliOptions, 'runFinished'> & {
-    /** SDK session id to resume on the first turn (e.g. after a crash-restart). */
-    resumeSessionId?: string;
-};
-export declare function runSessionServeCommand(options: SessionServeCliOptions): Promise<void>;

package/dist/commands/session-serve/index.js

@@ -1,100 +0,0 @@
-/**
- * `edsger session-serve <channelId>` — long-lived conversational agent for one
- * chat session.
- *
- * Where `session-turn` runs a single turn and exits, `session-serve` prepares
- * the session context once (repo clone, MCP toolbelt, system prompt) and then
- * stays alive, running one turn per command it reads from stdin. The SDK
- * session id is kept in memory and carried into the next turn automatically, so
- * the conversation (and prompt cache) stays warm without a per-turn cold start.
- *
- * Protocol — one JSON object per line on stdin:
- *   {"type":"turn"}                                  process pending messages
- *   {"type":"run-finished","runId":"…","command":"…"} report a finished cli_* run
- *   {"type":"shutdown"}                               drain + exit cleanly
- *
- * Turns run strictly one at a time (a session never has two turns in flight).
- * When stdin closes, the process exits after the current turn drains. Markers
- * (session id, background cli runs) are written to stdout exactly as the
- * one-shot command emits them, so the desktop's existing parsing is unchanged.
- */
-import { createInterface } from 'node:readline';
-import { logError, logInfo } from '../../utils/logger.js';
-import { prepareSessionContext, runTurn, } from '../session-turn/index.js';
-/**
- * Emitted once the session context is built and the process is ready to accept
- * turn commands on stdin. The desktop may use it to know the daemon is live;
- * it is harmless to ignore.
- */
-export const SESSION_READY_MARKER = '__EDSGER_SESSION_READY__';
-export async function runSessionServeCommand(options) {
-    const ctx = await prepareSessionContext(options);
-    process.stdout.write(`\n${SESSION_READY_MARKER}\n`);
-    logInfo(`Session ${ctx.channelId} ready — awaiting turns on stdin.`);
-    // Commands queue up here; we drain them one at a time so a session never has
-    // two turns running concurrently. `shuttingDown` stops accepting new work.
-    const queue = [];
-    let running = false;
-    let shuttingDown = false;
-    let stdinEnded = false;
-    const maybeExit = () => {
-        if ((shuttingDown || stdinEnded) && !running && queue.length === 0) {
-            logInfo(`Session ${ctx.channelId} shutting down.`);
-            process.exit(0);
-        }
-    };
-    const drain = async () => {
-        if (running) {
-            return;
-        }
-        running = true;
-        try {
-            while (queue.length > 0) {
-                const cmd = queue.shift();
-                if (cmd.type === 'shutdown') {
-                    shuttingDown = true;
-                    continue;
-                }
-                try {
-                    if (cmd.type === 'run-finished' && cmd.runId) {
-                        await runTurn(ctx, {
-                            runFinished: { runId: cmd.runId, command: cmd.command },
-                        });
-                    }
-                    else {
-                        await runTurn(ctx);
-                    }
-                }
-                catch (error) {
-                    logError(`Turn failed: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        finally {
-            running = false;
-            maybeExit();
-        }
-    };
-    const rl = createInterface({ input: process.stdin });
-    rl.on('line', (line) => {
-        const trimmed = line.trim();
-        if (!trimmed || shuttingDown) {
-            return;
-        }
-        let cmd;
-        try {
-            cmd = JSON.parse(trimmed);
-        }
-        catch {
-            logError(`Ignoring malformed command: ${trimmed}`);
-            return;
-        }
-        queue.push(cmd);
-        void drain();
-    });
-    // stdin closing is the desktop's normal "stop this session" signal.
-    rl.on('close', () => {
-        stdinEnded = true;
-        maybeExit();
-    });
-}

package/dist/commands/session-turn/index.d.ts

@@ -1,73 +0,0 @@
-/**
- * Marker emitted on stdout carrying the SDK session id, so the desktop can
- * persist it on the channel and pass it back via --resume next turn. Kept on
- * its own line and free of logger formatting so it parses cleanly.
- */
-export declare const SESSION_ID_MARKER = "__EDSGER_SESSION_ID__=";
-/**
- * Marker emitted on stdout for each background `cli_*` run still in flight when
- * the turn ends. The desktop main process parses these, watches each run to
- * completion (the turn process itself exits immediately), and then re-engages
- * the agent via `--run-finished` so it reports results without the user having
- * to ask. The JSON payload is `{ run_id, pid, log_path, command }`.
- */
-export declare const CLI_RUN_MARKER = "__EDSGER_CLI_RUN__=";
-import { loadExternalMcpServers } from 'edsger-tools';
-export interface SessionTurnCliOptions {
-    channelId: string;
-    productId: string;
-    repositoryIds?: string[];
-    /** SDK session id from a previous turn, to resume the same conversation. */
-    resumeSessionId?: string;
-    /**
-     * Follow-up turn triggered by the desktop watcher when a background `cli_*`
-     * run finishes. When set, the turn is driven by a synthetic prompt instead of
-     * the channel's pending human messages: the agent inspects what the run
-     * produced and reports it to the user.
-     */
-    runFinished?: {
-        runId: string;
-        command?: string;
-    };
-    verbose?: boolean;
-}
-/**
- * Everything a session needs to run turns, built once and reused. The daemon
- * keeps a single instance alive across turns so repo clones, the MCP toolbelt,
- * the system prompt, and the SDK session id all persist.
- */
-export interface SessionContext {
-    channelId: string;
-    productId: string;
-    repositoryIds: string[];
-    verbose: boolean;
-    sessionDir?: string;
-    systemPrompt: string;
-    sessionServer: any;
-    external: ReturnType<typeof loadExternalMcpServers>;
-    /** Latest SDK session id; carried into the next turn's `resume`. Mutable. */
-    sdkSessionId: string;
-}
-/**
- * Build the one-time session context: clone repos, assemble the MCP toolbelt
- * and external servers, and build the system prompt. Cheap to call once per
- * session process; expensive to call per turn (which is why the daemon doesn't).
- */
-export declare function prepareSessionContext(options: SessionTurnCliOptions): Promise<SessionContext>;
-/**
- * Run a single agent turn against an already-prepared {@link SessionContext}.
- * Mutates `ctx.sdkSessionId` so the next turn resumes the same SDK conversation
- * (and prompt cache). Safe to call repeatedly for the life of the process.
- */
-export declare function runTurn(ctx: SessionContext, opts?: {
-    runFinished?: {
-        runId: string;
-        command?: string;
-    };
-}): Promise<void>;
-/**
- * One-shot `session-turn`: prepare the context and run a single turn. Retained
- * for callers that want the previous per-turn-process behaviour (and as the
- * building block the daemon reuses).
- */
-export declare function runSessionTurnCommand(options: SessionTurnCliOptions): Promise<void>;

package/dist/commands/session-turn/index.js

@@ -1,254 +0,0 @@
-/**
- * Marker emitted on stdout carrying the SDK session id, so the desktop can
- * persist it on the channel and pass it back via --resume next turn. Kept on
- * its own line and free of logger formatting so it parses cleanly.
- */
-export const SESSION_ID_MARKER = '__EDSGER_SESSION_ID__=';
-/**
- * Marker emitted on stdout for each background `cli_*` run still in flight when
- * the turn ends. The desktop main process parses these, watches each run to
- * completion (the turn process itself exits immediately), and then re-engages
- * the agent via `--run-finished` so it reports results without the user having
- * to ask. The JSON payload is `{ run_id, pid, log_path, command }`.
- */
-export const CLI_RUN_MARKER = '__EDSGER_CLI_RUN__=';
-/**
- * `edsger session-turn <channelId>` — run one conversational agent turn for a
- * chat session (an ai_assistant channel bound to a product).
- *
- * Spawned by the desktop app when the user sends a message in a session. It
- * loads the channel's pending human messages, runs a single Claude Agent SDK
- * turn with the full session toolbelt (createSessionMcpServer — query/action/
- * engineering/cli + conversational + git/PR tools), then posts the reply back
- * to the channel and marks the messages processed. The agent decides what to
- * do (answer, generate stories/test cases, launch cli_* analyses, open PRs);
- * there is no fixed pipeline.
- *
- * The per-turn work is split into {@link prepareSessionContext} (one-time
- * workspace clone + toolbelt + prompt build) and {@link runTurn} (one agent
- * turn against that context). The one-shot `session-turn` command does both
- * once; the long-lived `session-serve` daemon prepares the context once and
- * calls {@link runTurn} repeatedly, keeping the SDK session warm across turns.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { buildSessionAgentOptions, buildSessionSystemPrompt, buildSessionUserPrompt, createSessionMcpServer, listActiveCliRuns, loadExternalMcpServers, SESSION_MAX_TURNS, } from 'edsger-tools';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { getToolDeps } from '../../tools/bootstrap.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneSessionRepos, describeSessionRepos, } from '../../workspace/session-workspace.js';
-/**
- * Clone (or refresh) the session product's repositories into a local session
- * directory and produce the agent's cwd + a prompt note describing the layout.
- *
- * One session dir holds every repo as a subdirectory; clones are reused across
- * turns. Best-effort: if nothing can be cloned (no GitHub config, private repo
- * the token can't reach), the agent still runs — it can answer, file issues,
- * etc. — just without a checked-out codebase.
- */
-async function prepareSessionWorkspace(opts) {
-    let workspace = null;
-    try {
-        workspace = await cloneSessionRepos(opts);
-    }
-    catch (error) {
-        logWarning(`Could not prepare session repos: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return {
-        sessionDir: workspace?.sessionDir,
-        repoScopeNote: workspace ? describeSessionRepos(workspace.repos) : '',
-    };
-}
-/**
- * Build the one-time session context: clone repos, assemble the MCP toolbelt
- * and external servers, and build the system prompt. Cheap to call once per
- * session process; expensive to call per turn (which is why the daemon doesn't).
- */
-export async function prepareSessionContext(options) {
-    const { channelId, productId, repositoryIds = [], resumeSessionId, verbose = false, } = options;
-    // Clone the product's in-scope repositories into a local session directory
-    // so the agent's Read/Grep/Glob can inspect the real code.
-    const { sessionDir, repoScopeNote } = await prepareSessionWorkspace({
-        channelId,
-        productId,
-        repositoryIds,
-        verbose,
-    });
-    const deps = getToolDeps({
-        verbose,
-        context: { productId, channelId, repositoryIds },
-    });
-    const sessionServer = createSessionMcpServer(deps);
-    // User-configured external MCP servers (~/.edsger/mcp.json). Best-effort.
-    const external = loadExternalMcpServers({ warn: logWarning });
-    if (external.names.length > 0) {
-        logInfo(`External MCP servers: ${external.names.join(', ')}`);
-    }
-    const systemPrompt = buildSessionSystemPrompt({
-        channelId,
-        productId,
-        repositoryIds,
-        repoScopeNote,
-        externalMcpNames: external.names,
-    });
-    return {
-        channelId,
-        productId,
-        repositoryIds,
-        verbose,
-        sessionDir,
-        systemPrompt,
-        sessionServer,
-        external,
-        sdkSessionId: resumeSessionId ?? '',
-    };
-}
-/** Emit the SDK session id so the desktop can persist it for the next turn. */
-function emitSessionId(id) {
-    if (id) {
-        process.stdout.write(`\n${SESSION_ID_MARKER}${id}\n`);
-    }
-}
-/**
- * Emit a marker for every background cli_* run still in flight, so the desktop
- * watcher can poll each to completion and re-engage the agent.
- */
-function emitActiveCliRuns() {
-    for (const run of listActiveCliRuns()) {
-        const payload = JSON.stringify({
-            run_id: run.run_id,
-            pid: run.pid,
-            log_path: run.log_path,
-            command: run.command,
-        });
-        process.stdout.write(`\n${CLI_RUN_MARKER}${payload}\n`);
-    }
-}
-/**
- * Run a single agent turn against an already-prepared {@link SessionContext}.
- * Mutates `ctx.sdkSessionId` so the next turn resumes the same SDK conversation
- * (and prompt cache). Safe to call repeatedly for the life of the process.
- */
-export async function runTurn(ctx, opts = {}) {
-    const { runFinished } = opts;
-    // 1. Decide what drives this turn. A normal turn replays the channel's
-    //    pending human messages; a watcher-triggered follow-up replays a
-    //    synthetic prompt about the background run that just finished.
-    let messages = [];
-    if (runFinished) {
-        logInfo(`Reporting completion of background run ${runFinished.runId} for session ${ctx.channelId}`);
-    }
-    else {
-        const pendingResult = (await callMcpEndpoint('chat/messages/pending', {
-            channel_id: ctx.channelId,
-        }));
-        messages = pendingResult.messages ?? [];
-        if (messages.length === 0) {
-            logInfo('No pending messages for this session — nothing to do.');
-            return;
-        }
-        logInfo(`Processing ${messages.length} message(s) for session ${ctx.channelId}`);
-    }
-    const userPrompt = runFinished
-        ? buildRunFinishedPrompt(runFinished)
-        : buildSessionUserPrompt(messages);
-    // 2. Run one SDK turn. Resume the prior SDK session when we have its id so
-    //    the conversation (and prompt cache) carries across turns. Point the
-    //    agent's cwd at the session directory so its read-only file tools resolve
-    //    against the cloned repos. Prompt + tool/MCP wiring come from the shared
-    //    session core (edsger-tools) so CLI and worker can't drift apart.
-    let finalResponse = '';
-    try {
-        for await (const message of query({
-            prompt: userPrompt,
-            options: {
-                ...buildSessionAgentOptions(ctx.systemPrompt, {
-                    sessionServer: ctx.sessionServer,
-                    externalServers: ctx.external.servers,
-                    externalNames: ctx.external.names,
-                    sessionDir: ctx.sessionDir,
-                    maxTurns: SESSION_MAX_TURNS,
-                }),
-                model: DEFAULT_MODEL,
-                ...(ctx.sdkSessionId ? { resume: ctx.sdkSessionId } : {}),
-            },
-        })) {
-            const msg = message;
-            // The system/init and result messages carry the (possibly new) session
-            // id — keep the latest so we persist what the next turn should resume.
-            if (msg.session_id) {
-                ctx.sdkSessionId = msg.session_id;
-            }
-            if (ctx.verbose && msg.type === 'assistant') {
-                logInfo('· agent step');
-            }
-            if (msg.type === 'result') {
-                finalResponse = msg.result || '';
-                break;
-            }
-        }
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        logError(`Session turn failed: ${reason}`);
-        await callMcpEndpoint('chat/messages/send_ai', {
-            channel_id: ctx.channelId,
-            content: `I hit an error processing that: ${reason}`,
-            message_type: 'text',
-            metadata: {},
-        }).catch(() => undefined);
-        emitSessionId(ctx.sdkSessionId);
-        emitActiveCliRuns();
-        await markProcessed(messages);
-        return;
-    }
-    // 3. Post the final reply (the agent may also have posted via
-    //    send_chat_message during the turn; this carries the closing summary).
-    const reply = finalResponse.trim();
-    if (reply) {
-        await callMcpEndpoint('chat/messages/send_ai', {
-            channel_id: ctx.channelId,
-            content: reply,
-            message_type: 'text',
-            metadata: {},
-        }).catch((e) => {
-            logError(`Failed to post reply: ${e instanceof Error ? e.message : String(e)}`);
-        });
-    }
-    // 4. Mark the triggering messages processed so they aren't re-run. (No-op for
-    //    a watcher follow-up, which has no triggering human messages.)
-    await markProcessed(messages);
-    // 5. Emit the SDK session id so the desktop persists it for the next turn,
-    //    plus a marker for any background run launched this turn so the watcher
-    //    keeps following it to completion.
-    emitSessionId(ctx.sdkSessionId);
-    emitActiveCliRuns();
-    logSuccess('Session turn complete.');
-}
-/**
- * One-shot `session-turn`: prepare the context and run a single turn. Retained
- * for callers that want the previous per-turn-process behaviour (and as the
- * building block the daemon reuses).
- */
-export async function runSessionTurnCommand(options) {
-    const ctx = await prepareSessionContext(options);
-    await runTurn(ctx, { runFinished: options.runFinished });
-}
-/**
- * The synthetic user prompt for a watcher-triggered follow-up turn. Steers the
- * agent to inspect what the finished run produced and report it — explicitly
- * NOT to ask the user whether it should check.
- */
-function buildRunFinishedPrompt(runFinished) {
-    const which = runFinished.command
-        ? `the \`${runFinished.command}\` analysis (run ${runFinished.runId})`
-        : `a background analysis you launched earlier (run ${runFinished.runId})`;
-    return `${which} just finished. Inspect what it produced — call get_cli_run with run_id "${runFinished.runId}" for the log tail, then use the list_* / get_* tools (e.g. list_issues) to see the findings it filed. Summarize the results for the user via send_chat_message. Do not ask whether you should check — just report what you found. If nothing of note was produced, say so briefly.`;
-}
-async function markProcessed(messages) {
-    for (const m of messages) {
-        await callMcpEndpoint('chat/messages/mark_processed', {
-            message_id: m.id,
-        }).catch(() => undefined);
-    }
-}

package/dist/commands/smoke-test/index.d.ts

@@ -1,5 +0,0 @@
-export interface SmokeTestCliOptions {
-    releaseId: string;
-    verbose?: boolean;
-}
-export declare const runSmokeTestCommand: (options: SmokeTestCliOptions) => Promise<void>;