pulseed 0.6.0 → 0.6.2

package/dist/interface/chat/chat-runner.js

@@ -3,18 +3,25 @@
 // Central coordinator for 1-shot chat execution (Tier 1).
 // Bypasses TaskLifecycle — calls adapter.execute() directly.
 import { getPulseedDirPath } from "../../base/utils/paths.js";
-import { getSelfIdentityResponseForBaseDir } from "../../base/config/identity-loader.js";
 import { ChatHistory } from "./chat-history.js";
 import { ChatSessionCatalog, ChatSessionSelectorError, } from "./chat-session-store.js";
 import { buildChatContext, resolveGitRoot } from "../../platform/observation/context-provider.js";
 import { buildChatAgentLoopSystemPrompt, buildStaticSystemPrompt, createChatGroundingGateway } from "./grounding.js";
-import { recognizeRuntimeControlIntent } from "../../runtime/control/index.js";
+import { classifyRuntimeControlIntent } from "../../runtime/control/index.js";
+import { classifyConfirmationDecision } from "../../runtime/confirmation-decision.js";
 import { createIngressRouter, } from "./ingress-router.js";
 import { classifyInterruptRedirect, collectGitDiffArtifact, previewActivityText } from "./chat-runner-support.js";
 import { COMMAND_HELP, ChatRunnerCommandHandler, } from "./chat-runner-commands.js";
 import { ChatRunnerEventBridge } from "./chat-runner-event-bridge.js";
+import { intakeSetupSecrets } from "./setup-secret-intake.js";
+import { isSetupWriteConfirmCommand, SETUP_WRITE_CONFIRM_COMMAND, } from "./setup-dialogue.js";
+import { detectTurnLanguageHint, sameLanguageResponseInstruction, UNKNOWN_TURN_LANGUAGE_HINT, } from "./turn-language.js";
+import { confirmTelegramGatewayConfigWrite } from "./setup-config-write.js";
 import { buildRuntimeControlContextFromIngress, buildStandaloneIngressMessageFromContext, formatRoute, getRouteCapabilities, loadedSessionToChatSession, resolveChatResumeSelector, } from "./chat-runner-runtime.js";
-import { executeAdapterRoute, executeAgentLoopRoute, executeRuntimeControlRoute, executeToolLoopRoute, resolveSessionExecutionPolicy, } from "./chat-runner-routes.js";
+import { executeAdapterRoute, executeAssistRoute, executeClarifyRoute, executeConfigureRoute, executeRunSpecDraftRoute, executeAgentLoopRoute, formatBlockedRuntimeControlRoute, executeRuntimeControlRoute, executeToolLoopRoute, resolveSessionExecutionPolicy, } from "./chat-runner-routes.js";
+import { classifyFreeformRouteIntent } from "./freeform-route-classifier.js";
+import { deriveRunSpecFromText } from "../../runtime/run-spec/index.js";
+import { createRunSpecStore, formatRunSpecSetupProposal, arbitrateRunSpecPendingDialogue, handleRunSpecConfirmationInput, RunSpecHandoffService, validateRunSpecStartSafety, } from "../../runtime/run-spec/index.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
 function normalizePinnedReplyTarget(replyTarget) {
     if (!replyTarget)
@@ -33,19 +40,40 @@ function normalizePinnedReplyTarget(replyTarget) {
     };
 }
 const standaloneIngressRouter = createIngressRouter();
-function resolveSelfIdentityResponse(input, baseDir) {
-    const normalized = input.trim().toLowerCase().replace(/\s+/g, "");
-    if (!normalized)
-        return null;
-    const isEnglishIdentityQuestion = /^(whoareyou|whatisyourname|what'syourname)[?]?$/.test(normalized);
-    const isIdentityQuestion = [
-        /^(あなた|君|きみ|お前|おまえ)(は|って)?(誰|だれ|何者|なにもの)(ですか|なの|です)?[？?]?$/,
-        /^(あなた|君|きみ|お前|おまえ)の名前(は|って)?(何|なに)(ですか|なの|です)?[？?]?$/,
-        /^名前(は|って)?(何|なに)(ですか|なの|です)?[？?]?$/,
-    ].some((pattern) => pattern.test(normalized));
-    if (!isIdentityQuestion && !isEnglishIdentityQuestion)
-        return null;
-    return getSelfIdentityResponseForBaseDir(baseDir, isEnglishIdentityQuestion ? "en" : "ja");
+function formatPendingSetupConfirmationSubject(publicState) {
+    const lines = [
+        `Setup dialogue: ${publicState.selectedChannel}`,
+        `State: ${publicState.state}`,
+        `Action: ${publicState.action?.kind ?? "unknown"}`,
+        `Command fallback: ${publicState.action?.command ?? SETUP_WRITE_CONFIRM_COMMAND}`,
+        publicState.replacesExistingSecret
+            ? "Confirming will replace an existing configured Telegram bot token."
+            : "Confirming will write a Telegram gateway config from a redacted chat-supplied token.",
+        "Approval is still required before writing config.",
+    ];
+    return lines.join("\n");
+}
+function formatSetupConfirmationCancelled(languageHint) {
+    if (languageHint.language === "ja") {
+        return "Telegram setup の config write はキャンセルしました。token は書き込んでいません。";
+    }
+    return "Telegram setup config write was cancelled. No token was written.";
+}
+function formatTelegramSetupRefreshResult(result, languageHint) {
+    if (result.success) {
+        const suffix = result.operationId ? ` (${result.operationId})` : "";
+        return languageHint.language === "ja"
+            ? `PulSeed は更新済み Telegram gateway config を反映するため、internal gateway refresh を要求しました${suffix}: ${result.message}`
+            : `PulSeed requested an internal gateway refresh for the updated Telegram config${suffix}: ${result.message}`;
+    }
+    if (result.unavailable) {
+        return languageHint.language === "ja"
+            ? `PulSeed は internal gateway refresh を試みましたが、この chat surface では runtime control service が利用できません: ${result.message}`
+            : `PulSeed attempted an internal gateway refresh, but runtime control is unavailable in this chat surface: ${result.message}`;
+    }
+    return languageHint.language === "ja"
+        ? `PulSeed は internal gateway refresh を試みましたが失敗しました: ${result.message}`
+        : `PulSeed attempted an internal gateway refresh, but it failed: ${result.message}`;
 }
 export class ChatRunner {
     deps;
@@ -65,6 +93,9 @@ export class ChatRunner {
     runtimeControlContext = null;
     sessionExecutionPolicy = null;
     lastSelectedRoute = null;
+    setupSecretIntake = null;
+    turnLanguageHint = UNKNOWN_TURN_LANGUAGE_HINT;
+    pendingSetupDialogue = null;
     constructor(deps) {
         this.deps = deps;
         this.groundingGateway = createChatGroundingGateway({
@@ -174,7 +205,7 @@ export class ChatRunner {
             output = [
                 "Interrupted the active turn.",
                 "",
-                "Recent activity",
+                "Activity before interruption",
                 ...(activeTurn.recentEvents.length > 0
                     ? activeTurn.recentEvents.slice(-6).map((event) => `- ${event}`)
                     : ["- No activity was captured before the interrupt."]),
@@ -206,14 +237,28 @@ export class ChatRunner {
         const activeTurn = this.eventBridge.beginActiveTurn(eventContext, resolvedCwd);
         const resumeCommand = this.commandHandler.parseResumeCommand(input);
         const resumeOnly = resumeCommand !== null;
+        const setupSecretIntake = intakeSetupSecrets(input);
+        this.setupSecretIntake = setupSecretIntake;
+        const safeInput = setupSecretIntake.redactedText;
+        this.turnLanguageHint = detectTurnLanguageHint(safeInput);
+        eventContext.languageHint = this.turnLanguageHint;
+        const persistedSecretIntake = setupSecretIntake.suppliedSecrets.map(({ value: _value, ...metadata }) => metadata);
         const runtimeControlContext = options.runtimeControlContext ?? this.runtimeControlContext;
         const executionGoalId = options.goalId ?? this.deps.goalId;
-        const commandResult = resumeOnly ? null : await this.commandHandler.handleCommand(input, resolvedCwd);
+        const pendingTelegramSetupResult = await this.handlePendingSetupConfirmation(safeInput, runtimeControlContext);
+        if (pendingTelegramSetupResult !== null) {
+            return this.finalizeNonPersistentResult(pendingTelegramSetupResult, eventContext);
+        }
+        const pendingRunSpecConfirmationResult = await this.handlePendingRunSpecConfirmation(safeInput);
+        if (pendingRunSpecConfirmationResult !== null) {
+            return this.finalizeNonPersistentResult(pendingRunSpecConfirmationResult, eventContext);
+        }
+        const commandResult = resumeOnly ? null : await this.commandHandler.handleCommand(safeInput, resolvedCwd);
         if (commandResult !== null) {
             return this.finalizeNonPersistentResult(commandResult, eventContext);
         }
         if (this.pendingTend !== null && !resumeOnly) {
-            const confirmationResult = await this.commandHandler.handleTendConfirmation(input.trim(), Date.now());
+            const confirmationResult = await this.commandHandler.handleTendConfirmation(safeInput.trim(), Date.now());
             return this.finalizeNonPersistentResult(confirmationResult, eventContext);
         }
         if (resumeOnly && resumeCommand.selector) {
@@ -258,11 +303,11 @@ export class ChatRunner {
         }
         this.eventBridge.emitEvent({
             type: "lifecycle_start",
-            input,
+            input: safeInput,
             ...this.eventBridge.eventBase(eventContext),
         });
         if (!resumeOnly) {
-            await history.appendUserMessage(input);
+            await history.appendUserMessage(safeInput, { setupSecretIntake: persistedSecretIntake });
         }
         if (this.cachedStaticSystemPrompt === null) {
             try {
@@ -284,30 +329,14 @@ export class ChatRunner {
             historySections.push(`Previous conversation:\n${lines}`);
         }
         const historyBlock = historySections.length > 0 ? `${historySections.join("\n\n")}\n\nCurrent message:\n` : "";
+        const start = Date.now();
+        const assistantBuffer = { text: "" };
         const selectedRoute = resumeOnly
             ? null
-            : (options.selectedRoute ?? await this.resolveRouteFromInput(input, runtimeControlContext));
+            : (options.selectedRoute ?? await this.resolveRouteFromInput(safeInput, runtimeControlContext, resolvedCwd));
         this.lastSelectedRoute = selectedRoute;
-        this.eventBridge.emitIntent(input, selectedRoute, eventContext);
-        const start = Date.now();
-        const assistantBuffer = { text: "" };
-        const identityResponse = resumeOnly ? null : resolveSelfIdentityResponse(input, this.providerConfigBaseDir());
-        if (identityResponse !== null) {
-            const elapsed_ms = Date.now() - start;
-            await history.appendAssistantMessage(identityResponse);
-            this.eventBridge.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
-            this.eventBridge.emitEvent({
-                type: "assistant_final",
-                text: identityResponse,
-                persisted: true,
-                ...this.eventBridge.eventBase(eventContext),
-            });
-            this.eventBridge.emitLifecycleEndEvent("completed", elapsed_ms, eventContext, true);
-            return {
-                success: true,
-                output: identityResponse,
-                elapsed_ms,
-            };
+        if (selectedRoute?.kind !== "configure") {
+            this.eventBridge.emitIntent(safeInput, selectedRoute, eventContext);
         }
         if (selectedRoute?.kind === "runtime_control") {
             this.eventBridge.emitCheckpoint("Runtime control selected", `${selectedRoute.intent.kind} request recognized.`, eventContext, "route");
@@ -336,9 +365,50 @@ export class ChatRunner {
             }
             return runtimeControlResult;
         }
+        if (selectedRoute?.kind === "runtime_control_blocked") {
+            const output = formatBlockedRuntimeControlRoute(selectedRoute);
+            this.eventBridge.pushAssistantDelta(output, assistantBuffer, eventContext);
+            await history.appendAssistantMessage(output);
+            this.eventBridge.emitEvent({
+                type: "assistant_final",
+                text: output,
+                persisted: true,
+                ...this.eventBridge.eventBase(eventContext),
+            });
+            const elapsed_ms = Date.now() - start;
+            this.eventBridge.emitLifecycleEndEvent("error", elapsed_ms, eventContext, true);
+            return {
+                success: false,
+                output,
+                elapsed_ms,
+            };
+        }
+        if (selectedRoute?.kind === "run_spec_draft") {
+            const result = await executeRunSpecDraftRoute(this.routeHost(), selectedRoute, eventContext, assistantBuffer, history, start);
+            return result;
+        }
+        if (selectedRoute?.kind === "configure") {
+            const result = await executeConfigureRoute(this.routeHost(), selectedRoute, eventContext, assistantBuffer, history, start);
+            return result;
+        }
+        if (selectedRoute?.kind === "clarify") {
+            const result = await executeClarifyRoute(this.routeHost(), selectedRoute, eventContext, assistantBuffer, history, start);
+            return result;
+        }
+        if (selectedRoute?.kind === "assist") {
+            const result = await executeAssistRoute(this.routeHost(), {
+                input: safeInput,
+                priorTurns,
+                eventContext,
+                assistantBuffer,
+                history,
+                start,
+            });
+            return result;
+        }
         const usesNativeAgentLoop = resumeOnly || selectedRoute?.kind === "agent_loop";
         const groundingWorkspaceContext = !resumeOnly && usesNativeAgentLoop
-            ? await buildChatContext(input, executionCwd)
+            ? await buildChatContext(safeInput, executionCwd)
             : undefined;
         let systemPrompt = this.cachedStaticSystemPrompt ?? "";
         if (!resumeOnly) {
@@ -350,7 +420,7 @@ export class ChatRunner {
                         pluginLoader: this.deps.pluginLoader,
                         workspaceRoot: executionCwd,
                         goalId: executionGoalId,
-                        userMessage: input,
+                        userMessage: safeInput,
                         trustProjectInstructions: this.sessionExecutionPolicy?.trustProjectInstructions ?? true,
                         workspaceContext: groundingWorkspaceContext,
                     });
@@ -361,8 +431,8 @@ export class ChatRunner {
                         purpose: "general_turn",
                         workspaceRoot: executionCwd,
                         goalId: executionGoalId,
-                        userMessage: input,
-                        query: input,
+                        userMessage: safeInput,
+                        query: safeInput,
                         trustProjectInstructions: this.sessionExecutionPolicy?.trustProjectInstructions ?? true,
                     });
                     systemPrompt = String(groundingBundle.render("prompt"));
@@ -377,13 +447,14 @@ export class ChatRunner {
         }
         const agentLoopSystemPrompt = [
             systemPrompt,
+            sameLanguageResponseInstruction(this.turnLanguageHint),
             compactionSummary ? `## Compacted Chat Summary\n${compactionSummary}` : "",
         ]
             .filter((section) => section && section.trim().length > 0)
             .join("\n\n")
             .trim();
-        const context = resumeOnly || usesNativeAgentLoop ? "" : await buildChatContext(input, gitRoot);
-        const basePrompt = resumeOnly ? "" : (context ? `${context}\n\n${input}` : input);
+        const context = resumeOnly || usesNativeAgentLoop ? "" : await buildChatContext(safeInput, gitRoot);
+        const basePrompt = resumeOnly ? "" : (context ? `${context}\n\n${safeInput}` : safeInput);
         const prompt = historyBlock ? `${historyBlock}${basePrompt}` : basePrompt;
         if (resumeOnly && !this.deps.chatAgentLoopRunner) {
             const elapsed_ms = Date.now() - start;
@@ -406,6 +477,7 @@ export class ChatRunner {
                 eventContext,
                 history,
                 gitRoot,
+                runtimeControlContext,
                 activeAbortSignal: activeTurn.abortController.signal,
                 start,
             });
@@ -419,6 +491,7 @@ export class ChatRunner {
                 executionGoalId,
                 history,
                 gitRoot,
+                runtimeControlContext,
                 start,
             });
         }
@@ -456,20 +529,73 @@ export class ChatRunner {
     }
     async resolveRouteFromIngress(ingress) {
         const capabilities = getRouteCapabilities(this.deps);
-        const runtimeControlAllowed = ingress.runtimeControl.allowed
-            && ingress.runtimeControl.approvalMode !== "disallowed"
-            && (capabilities.hasRuntimeControlService
-                || (!capabilities.hasAgentLoop && !capabilities.hasToolLoop));
-        const runtimeControlIntent = runtimeControlAllowed
-            ? await recognizeRuntimeControlIntent(ingress.text, this.deps.llmClient)
+        const hasSetupSecret = (this.setupSecretIntake?.suppliedSecrets.length ?? 0) > 0;
+        const shouldPreferFreeformBeforeDeniedRuntimeControl = !hasSetupSecret
+            && !capabilities.hasAgentLoop
+            && ingress.metadata["runtime_control_denied"] === true
+            && ingress.metadata["runtime_control_approved"] !== true
+            && ingress.metadata["runtime_control_explicit"] !== true;
+        const shouldClassifyRuntimeControlForSafety = !hasSetupSecret
+            && capabilities.hasAgentLoop
+            && (ingress.metadata["runtime_control_approved"] === true
+                || ingress.metadata["runtime_control_denied"] === true
+                || ingress.metadata["runtime_control_explicit"] === true);
+        const shouldClassifyRuntimeControl = shouldClassifyRuntimeControlForSafety
+            || (!hasSetupSecret && !capabilities.hasAgentLoop && ((capabilities.hasRuntimeControlService && ingress.runtimeControl.approvalMode !== "disallowed")
+                || ingress.metadata["runtime_control_approved"] === true
+                || ingress.metadata["runtime_control_denied"] === true
+                || ingress.metadata["runtime_control_explicit"] === true));
+        let freeformRouteIntent = shouldPreferFreeformBeforeDeniedRuntimeControl
+            ? await classifyFreeformRouteIntent(ingress.text, this.deps.llmClient)
+            : null;
+        const runtimeControlClassification = freeformRouteIntent == null && shouldClassifyRuntimeControl
+            ? await classifyRuntimeControlIntent(ingress.text, this.deps.llmClient)
+            : null;
+        const runtimeControlIntent = runtimeControlClassification?.status === "intent"
+            ? runtimeControlClassification.intent
+            : null;
+        if (!hasSetupSecret && !capabilities.hasAgentLoop && freeformRouteIntent == null && runtimeControlIntent === null) {
+            freeformRouteIntent = await classifyFreeformRouteIntent(ingress.text, this.deps.llmClient);
+        }
+        const shouldDeriveRunSpecDraft = !capabilities.hasAgentLoop
+            && !hasSetupSecret
+            && runtimeControlIntent === null
+            && freeformRouteIntent != null
+            && (freeformRouteIntent.kind === "run_spec"
+                || freeformRouteIntent.kind === "configure"
+                || freeformRouteIntent.kind === "clarify")
+            && freeformRouteIntent.confidence >= 0.7;
+        const runSpecDraft = shouldDeriveRunSpecDraft
+            ? await deriveRunSpecFromText(ingress.text, {
+                cwd: ingress.cwd ?? this.sessionCwd ?? undefined,
+                conversationId: ingress.conversation_id ?? null,
+                channel: ingress.channel,
+                sessionId: this.history?.getSessionId() ?? ingress.conversation_id ?? null,
+                replyTarget: ingress.replyTarget,
+                originMetadata: {
+                    ingress_id: ingress.ingress_id ?? null,
+                    platform: ingress.platform ?? null,
+                    message_id: ingress.message_id ?? null,
+                    deliveryMode: ingress.deliveryMode ?? null,
+                    metadata: ingress.metadata,
+                },
+                llmClient: this.deps.llmClient,
+            })
             : null;
         return standaloneIngressRouter.selectRoute(ingress, {
             ...capabilities,
             runtimeControlIntent,
+            runtimeControlUnclassified: shouldClassifyRuntimeControlForSafety
+                && runtimeControlClassification?.status === "unclassified"
+                && ingress.metadata["runtime_control_explicit"] === true,
+            freeformRouteIntent,
+            setupSecretIntake: this.setupSecretIntake,
+            runSpecDraft,
         });
     }
-    async resolveRouteFromInput(input, runtimeControlContext) {
-        return this.resolveRouteFromIngress(buildStandaloneIngressMessageFromContext(input, runtimeControlContext, this.deps));
+    async resolveRouteFromInput(input, runtimeControlContext, cwd) {
+        const ingress = buildStandaloneIngressMessageFromContext(input, runtimeControlContext, this.deps);
+        return this.resolveRouteFromIngress(cwd ? { ...ingress, cwd } : ingress);
     }
     loadedSessionToChatSession(session) {
         return loadedSessionToChatSession(session);
@@ -482,6 +608,20 @@ export class ChatRunner {
             getConversationSessionId: () => this.history?.getSessionId() ?? null,
             getSessionCwd: () => this.sessionCwd,
             getNativeAgentLoopStatePath: () => this.nativeAgentLoopStatePath,
+            getProviderConfigBaseDir: () => this.providerConfigBaseDir(),
+            getSetupSecretIntake: () => this.setupSecretIntake,
+            getTurnLanguageHint: () => this.turnLanguageHint,
+            setPendingSetupDialogue: async (dialogue) => {
+                this.pendingSetupDialogue = dialogue;
+                this.history?.setSetupDialogue(dialogue?.publicState ?? null);
+                await this.history?.persist();
+            },
+            getPendingSetupDialogue: () => this.pendingSetupDialogue,
+            setPendingRunSpecConfirmation: async (confirmation) => {
+                this.history?.setRunSpecConfirmation(confirmation);
+                await this.history?.persist();
+            },
+            getPendingRunSpecConfirmation: () => this.history?.getRunSpecConfirmation() ?? null,
             getSessionExecutionPolicy: () => this.getSessionExecutionPolicy(),
             setSessionExecutionPolicy: (policy) => { this.sessionExecutionPolicy = policy; },
         };
@@ -490,6 +630,235 @@ export class ChatRunner {
         const stateManager = this.deps.stateManager;
         return typeof stateManager.getBaseDir === "function" ? stateManager.getBaseDir() : getPulseedDirPath();
     }
+    async handlePendingRunSpecConfirmation(input) {
+        const pending = this.history?.getRunSpecConfirmation() ?? null;
+        if (!pending || pending.state !== "pending")
+            return null;
+        const start = Date.now();
+        const result = await handleRunSpecConfirmationInput(pending.spec, input, {
+            llmClient: this.deps.llmClient,
+        });
+        const store = createRunSpecStore(this.deps.stateManager);
+        await store.save(result.spec);
+        if (result.kind === "confirmed") {
+            const safetyBlock = validateRunSpecStartSafety(result.spec);
+            if (safetyBlock) {
+                const pendingSpec = {
+                    ...result.spec,
+                    status: "draft",
+                };
+                await store.save(pendingSpec);
+                this.history?.setRunSpecConfirmation({
+                    ...pending,
+                    state: "pending",
+                    spec: pendingSpec,
+                    updatedAt: pendingSpec.updated_at,
+                });
+                await this.history?.persist();
+                return {
+                    success: false,
+                    output: safetyBlock,
+                    elapsed_ms: Date.now() - start,
+                };
+            }
+            const started = await this.startConfirmedRunSpec(result.spec);
+            this.history?.setRunSpecConfirmation({
+                ...pending,
+                state: "confirmed",
+                spec: result.spec,
+                updatedAt: result.spec.updated_at,
+            });
+            await this.history?.persist();
+            return { ...started, elapsed_ms: Date.now() - start };
+        }
+        if (result.kind === "cancelled") {
+            this.history?.setRunSpecConfirmation(null);
+            await this.history?.persist();
+            return {
+                success: false,
+                output: `${result.message}\nNo background run was started.`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        if (result.kind === "revised") {
+            const proposal = formatRunSpecSetupProposal(result.spec);
+            this.history?.setRunSpecConfirmation({
+                ...pending,
+                spec: result.spec,
+                prompt: proposal,
+                updatedAt: result.spec.updated_at,
+            });
+            await this.history?.persist();
+            return {
+                success: true,
+                output: [
+                    proposal,
+                    "",
+                    "RunSpec updated. Reply with approval to confirm, cancel to discard it, or provide another update.",
+                ].join("\n"),
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        if (result.kind === "blocked") {
+            this.history?.setRunSpecConfirmation({
+                ...pending,
+                spec: result.spec,
+                updatedAt: result.spec.updated_at,
+            });
+            await this.history?.persist();
+            return {
+                success: false,
+                output: result.message,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        const dialogue = await arbitrateRunSpecPendingDialogue(pending.spec, input, {
+            llmClient: this.deps.llmClient,
+        });
+        if (dialogue.outcome === "new_intent") {
+            return null;
+        }
+        return {
+            success: false,
+            output: result.message,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async startConfirmedRunSpec(spec) {
+        const start = Date.now();
+        const result = await new RunSpecHandoffService({
+            stateManager: this.deps.stateManager,
+            llmClient: this.deps.llmClient,
+            daemonClient: this.deps.daemonClient,
+            conversationSessionId: this.history?.getSessionId() ?? spec.origin.session_id,
+            sessionCwd: this.sessionCwd,
+            replyTarget: (this.runtimeControlContext?.replyTarget
+                ?? this.deps.runtimeReplyTarget
+                ?? spec.origin.reply_target
+                ?? null),
+        }).startConfirmed(spec);
+        return {
+            success: result.success,
+            output: result.message,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handlePendingSetupConfirmation(input, runtimeControlContext) {
+        const commandConfirmed = isSetupWriteConfirmCommand(input);
+        const pendingAtInput = this.pendingSetupDialogue;
+        if (!commandConfirmed) {
+            if (!pendingAtInput || pendingAtInput.publicState.state !== "confirm_write")
+                return null;
+            const decision = await classifyConfirmationDecision(input, {
+                llmClient: this.deps.llmClient,
+                kind: "approval",
+                subject: formatPendingSetupConfirmationSubject(pendingAtInput.publicState),
+                allowedDecisions: ["approve", "cancel", "unknown"],
+            });
+            if (decision.decision === "cancel") {
+                this.pendingSetupDialogue = null;
+                this.history?.setSetupDialogue(null);
+                await this.history?.persist();
+                return {
+                    success: false,
+                    output: formatSetupConfirmationCancelled(this.turnLanguageHint),
+                    elapsed_ms: 0,
+                };
+            }
+            if (decision.decision !== "approve")
+                return null;
+        }
+        const pending = this.pendingSetupDialogue;
+        if (!pending) {
+            return {
+                success: false,
+                output: "No pending setup write is available. Paste the secret again to start a protected setup turn.",
+                elapsed_ms: 0,
+            };
+        }
+        if (pending.publicState.selectedChannel !== "telegram" || pending.publicState.action?.kind !== "write_gateway_config") {
+            return {
+                success: false,
+                output: `The pending setup dialogue is for ${pending.publicState.selectedChannel}, so it cannot be confirmed as a Telegram config write. Start a new Telegram setup turn with a Telegram bot token.`,
+                elapsed_ms: 0,
+            };
+        }
+        if (!pending.secretValue) {
+            return {
+                success: false,
+                output: "The pending setup dialogue no longer has a transient secret value. Paste the token again so PulSeed can keep it protected through a fresh confirmation.",
+                elapsed_ms: 0,
+            };
+        }
+        const approvalFn = runtimeControlContext
+            ? runtimeControlContext.approvalFn
+            : this.deps.runtimeControlApprovalFn ?? this.deps.approvalFn;
+        if (!approvalFn) {
+            return {
+                success: false,
+                output: "Telegram setup requires an approval-capable chat surface before writing config. Use `pulseed telegram setup` instead.",
+                elapsed_ms: 0,
+            };
+        }
+        const writeResult = await confirmTelegramGatewayConfigWrite({
+            pending,
+            baseDir: this.providerConfigBaseDir(),
+            approvalFn,
+            runtimeControlService: this.deps.runtimeControlService,
+            actor: runtimeControlContext?.actor,
+            replyTarget: runtimeControlContext?.replyTarget,
+        });
+        if (!writeResult.success) {
+            this.pendingSetupDialogue = null;
+            this.history?.setSetupDialogue(null);
+            await this.history?.persist();
+            return {
+                success: false,
+                output: writeResult.message,
+                elapsed_ms: 0,
+            };
+        }
+        this.pendingSetupDialogue = {
+            publicState: {
+                ...pending.publicState,
+                state: writeResult.refresh.success ? "verify" : "restart_offer",
+                updatedAt: new Date().toISOString(),
+                action: pending.publicState.action
+                    ? { ...pending.publicState.action, status: "completed" }
+                    : pending.publicState.action,
+            },
+        };
+        this.history?.setSetupDialogue(this.pendingSetupDialogue.publicState);
+        await this.history?.persist();
+        return {
+            success: true,
+            output: [
+                this.turnLanguageHint.language === "ja"
+                    ? "redacted chat-supplied token から Telegram gateway config を書き込みました。"
+                    : "Telegram gateway config was written from the redacted chat-supplied token.",
+                "",
+                formatTelegramSetupRefreshResult(writeResult.refresh, this.turnLanguageHint),
+                "",
+                this.turnLanguageHint.language === "ja" ? "Next steps:" : "Next steps:",
+                ...(writeResult.accessClosedByDefault
+                    ? [this.turnLanguageHint.language === "ja"
+                            ? "- allowed Telegram user IDs を設定するか、`pulseed telegram setup` で意図的に `allow_all` を有効にするまで access は closed のままです。"
+                            : "- Access remains closed until you configure allowed Telegram user IDs or intentionally enable `allow_all` with `pulseed telegram setup`."]
+                    : []),
+                this.turnLanguageHint.language === "ja"
+                    ? "- home chat が未設定なら Telegram から `/sethome` を送ってください。"
+                    : "- Send `/sethome` from Telegram if no home chat is configured yet.",
+                writeResult.refresh.success
+                    ? this.turnLanguageHint.language === "ja"
+                        ? "- Telegram bot にメッセージを送って動作確認してください。"
+                        : "- Send a message to the Telegram bot to verify delivery."
+                    : this.turnLanguageHint.language === "ja"
+                        ? "- 自動反映できませんでした。daemon lifecycle 操作は typed runtime-control が利用可能な chat surface から再実行してください。"
+                        : "- Automatic refresh was not applied. Retry the lifecycle refresh from a chat surface with typed runtime-control available.",
+            ].join("\n"),
+            elapsed_ms: 0,
+        };
+    }
     finalizeNonPersistentResult(result, eventContext) {
         if (result.output) {
             this.eventBridge.emitEvent({