@useorgx/openclaw-plugin 0.7.0 → 0.7.3

package/dist/http/helpers/auto-continue-engine.js

@@ -34,11 +34,548 @@ export function createAutoContinueEngine(deps) {
     const decisionAutoResolveGuardedEnabled = String(process.env.DECISION_AUTO_RESOLVE_GUARDED_ENABLED ?? "true")
         .trim()
         .toLowerCase() !== "false";
+    const questionAutoAnswerPolicyByScope = new Map();
+    const pendingQuestionAutoAnswerByScope = new Map();
+    const QUESTION_AUTO_ANSWER_DEFAULT_TIMEOUT_SECONDS = readBudgetEnvNumber("ORGX_QUESTION_AUTO_ANSWER_TIMEOUT_SEC", readBudgetEnvNumber("ORGX_QUESTION_AUTO_ANSWER_DELAY_SECONDS", 60, {
+        min: 1,
+        max: 900,
+    }), { min: 1, max: 3600 });
+    const QUESTION_AUTO_ANSWER_DEFAULT_ENABLED = String(process.env.ORGX_QUESTION_AUTO_ANSWER_ENABLED ?? "true")
+        .trim()
+        .toLowerCase() !== "false";
+    const QUESTION_AUTO_ANSWER_DEFAULT_MODE = String(process.env.ORGX_QUESTION_AUTO_ANSWER_POLICY ?? "contextual")
+        .trim()
+        .toLowerCase() === "approve_non_blocking"
+        ? "approve_non_blocking"
+        : String(process.env.ORGX_QUESTION_AUTO_ANSWER_POLICY ?? "contextual")
+            .trim()
+            .toLowerCase() === "defer_non_blocking"
+            ? "defer_non_blocking"
+            : "contextual";
+    const QUESTION_BLOCKING_BEHAVIOR_DEFAULT = String(process.env.ORGX_QUESTION_BLOCKING_BEHAVIOR ?? "require_human")
+        .trim()
+        .toLowerCase() === "guarded_auto_resolve_then_human"
+        ? "guarded_auto_resolve_then_human"
+        : "require_human";
+    const QUESTION_AUTO_ANSWER_DEFAULT_ACTION = String(process.env.ORGX_QUESTION_AUTO_ANSWER_ACTION ?? "approve")
+        .trim()
+        .toLowerCase() === "reject"
+        ? "reject"
+        : "approve";
+    const autoContinueSliceRuns = new Map();
     /** Spread into any metadata object to flag mock-worker activity. */
     function mockMeta(slice) {
         return slice.isMockWorker ? { mock: true } : {};
     }
+    function normalizeRuntimeSourceClient(value) {
+        const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+        if (!normalized)
+            return "unknown";
+        if (normalized === "codex")
+            return "codex";
+        if (normalized === "claude-code" || normalized === "claude_code")
+            return "claude-code";
+        if (normalized === "openclaw")
+            return "openclaw";
+        if (normalized === "api")
+            return "api";
+        return "unknown";
+    }
+    const normalizeQuestionAutoAnswerPolicy = (runtimeSettings) => {
+        const workspaceDefaults = runtimeSettings?.workspace_question_defaults &&
+            typeof runtimeSettings.workspace_question_defaults === "object"
+            ? runtimeSettings.workspace_question_defaults
+            : null;
+        const enabledRaw = runtimeSettings?.question_auto_answer_enabled;
+        const timeoutRaw = runtimeSettings?.question_auto_answer_timeout_sec ??
+            runtimeSettings?.question_auto_answer_delay_seconds;
+        const workspaceTimeoutRaw = workspaceDefaults?.question_auto_answer_timeout_sec ??
+            workspaceDefaults
+                ?.question_auto_answer_delay_seconds;
+        const actionRaw = runtimeSettings?.question_auto_answer_action;
+        const modeRaw = runtimeSettings?.question_auto_answer_policy;
+        const workspaceModeRaw = workspaceDefaults?.question_auto_answer_policy;
+        const blockingBehaviorRaw = runtimeSettings?.question_blocking_behavior;
+        const workspaceBlockingBehaviorRaw = workspaceDefaults?.question_blocking_behavior;
+        const policyVersionRaw = runtimeSettings?.question_policy_version;
+        const timeoutSeconds = typeof timeoutRaw === "number" && Number.isFinite(timeoutRaw)
+            ? Math.max(1, Math.min(3600, Math.floor(timeoutRaw)))
+            : typeof workspaceTimeoutRaw === "number" && Number.isFinite(workspaceTimeoutRaw)
+                ? Math.max(1, Math.min(3600, Math.floor(workspaceTimeoutRaw)))
+                : QUESTION_AUTO_ANSWER_DEFAULT_TIMEOUT_SECONDS;
+        const mode = modeRaw === "approve_non_blocking" ||
+            modeRaw === "defer_non_blocking" ||
+            modeRaw === "contextual"
+            ? modeRaw
+            : workspaceModeRaw === "approve_non_blocking" ||
+                workspaceModeRaw === "defer_non_blocking" ||
+                workspaceModeRaw === "contextual"
+                ? workspaceModeRaw
+                : QUESTION_AUTO_ANSWER_DEFAULT_MODE;
+        const action = actionRaw === "reject" || actionRaw === "approve"
+            ? actionRaw
+            : mode === "defer_non_blocking"
+                ? "reject"
+                : QUESTION_AUTO_ANSWER_DEFAULT_ACTION;
+        const blockingBehavior = blockingBehaviorRaw === "guarded_auto_resolve_then_human" ||
+            blockingBehaviorRaw === "require_human"
+            ? blockingBehaviorRaw
+            : workspaceBlockingBehaviorRaw === "guarded_auto_resolve_then_human" ||
+                workspaceBlockingBehaviorRaw === "require_human"
+                ? workspaceBlockingBehaviorRaw
+                : QUESTION_BLOCKING_BEHAVIOR_DEFAULT;
+        const enabled = typeof enabledRaw === "boolean"
+            ? enabledRaw
+            : typeof workspaceDefaults?.question_auto_answer_enabled === "boolean"
+                ? workspaceDefaults.question_auto_answer_enabled
+                : QUESTION_AUTO_ANSWER_DEFAULT_ENABLED;
+        const policyVersion = typeof policyVersionRaw === "number" && Number.isFinite(policyVersionRaw)
+            ? Math.max(1, Math.min(10, Math.floor(policyVersionRaw)))
+            : 1;
+        return {
+            enabled,
+            timeoutSeconds,
+            mode,
+            action,
+            blockingBehavior,
+            policyVersion,
+        };
+    };
+    const questionScopeKey = (initiativeId, workstreamId) => {
+        const normalizedInitiativeId = (initiativeId ?? "").trim() || "unknown_initiative";
+        const normalizedWorkstreamId = (workstreamId ?? "").trim() || "all_workstreams";
+        return `${normalizedInitiativeId}::${normalizedWorkstreamId}`;
+    };
+    const resolveQuestionPolicy = (initiativeId, workstreamId) => {
+        const scoped = questionAutoAnswerPolicyByScope.get(questionScopeKey(initiativeId, workstreamId));
+        if (scoped)
+            return scoped;
+        const initiativeWide = questionAutoAnswerPolicyByScope.get(questionScopeKey(initiativeId, null));
+        if (initiativeWide)
+            return initiativeWide;
+        return {
+            enabled: QUESTION_AUTO_ANSWER_DEFAULT_ENABLED,
+            timeoutSeconds: QUESTION_AUTO_ANSWER_DEFAULT_TIMEOUT_SECONDS,
+            mode: QUESTION_AUTO_ANSWER_DEFAULT_MODE,
+            action: QUESTION_AUTO_ANSWER_DEFAULT_ACTION,
+            blockingBehavior: QUESTION_BLOCKING_BEHAVIOR_DEFAULT,
+            policyVersion: 1,
+        };
+    };
+    const clearQuestionAutoAnswerStateForInitiative = (initiativeId) => {
+        const normalizedInitiativeId = (initiativeId ?? "").trim();
+        if (!normalizedInitiativeId)
+            return;
+        for (const [key, pending] of pendingQuestionAutoAnswerByScope.entries()) {
+            if ((pending.initiativeId ?? "").trim() !== normalizedInitiativeId)
+                continue;
+            if (pending.timer) {
+                clearTimeout(pending.timer);
+            }
+            pendingQuestionAutoAnswerByScope.delete(key);
+        }
+    };
+    const processQuestionAutoAnswer = async (key, pending) => {
+        pendingQuestionAutoAnswerByScope.delete(key);
+        const note = pending.action === "approve"
+            ? "Auto-approved after timeout: no human answer received within configured delay."
+            : "Auto-rejected after timeout: no human answer received within configured delay.";
+        const decisionIds = pending.decisionIds;
+        if (decisionIds.length === 0) {
+            return;
+        }
+        await emitActivitySafe({
+            initiativeId: pending.initiativeId,
+            runId: pending.sourceRunId,
+            correlationId: pending.sourceRunId,
+            phase: "review",
+            level: "info",
+            progressPct: 0,
+            nextStep: "Applying question answer policy to unresolved items.",
+            message: "Question auto-answered after timeout; applying decision updates.",
+            metadata: {
+                event: "question_auto_answered",
+                action_type: normalizeActivityActionType("question_auto_answered"),
+                action_phase: normalizeActivityActionPhase("review"),
+                initiative_id: pending.initiativeId,
+                workstream_id: pending.workstreamId,
+                source_run_id: pending.sourceRunId,
+                source_client: pending.sourceClient,
+                decision_ids: decisionIds,
+                decision_count: decisionIds.length,
+                decision_action: pending.action,
+                timeout_seconds_applied: pending.timeoutSeconds,
+            },
+        });
+        let applied = 0;
+        let failed = 0;
+        const failures = [];
+        for (const decisionId of decisionIds) {
+            try {
+                await client.decideDecision(decisionId, pending.action, { note });
+                applied += 1;
+            }
+            catch (err) {
+                failed += 1;
+                failures.push({
+                    id: decisionId,
+                    error: safeErrorMessage(err),
+                });
+            }
+        }
+        await emitActivitySafe({
+            initiativeId: pending.initiativeId,
+            runId: pending.sourceRunId,
+            correlationId: pending.sourceRunId,
+            phase: failed > 0 ? "blocked" : "review",
+            level: failed > 0 ? "warn" : "info",
+            progressPct: 100,
+            nextStep: failed > 0
+                ? "Review failed auto-answer decisions and resolve manually."
+                : "Decision queue was auto-resolved; run can continue.",
+            message: failed > 0
+                ? `Question answers processed (${applied} applied, ${failed} failed).`
+                : `Question answer ${pending.action} applied to ${applied} queued items.`,
+            metadata: {
+                event: failed > 0 ? "question_answer_failed" : "question_answer_applied",
+                action_type: normalizeActivityActionType(failed > 0 ? "question_answer_failed" : "question_answer_applied"),
+                action_phase: normalizeActivityActionPhase(failed > 0 ? "blocked" : "review"),
+                initiative_id: pending.initiativeId,
+                workstream_id: pending.workstreamId,
+                source_run_id: pending.sourceRunId,
+                source_client: pending.sourceClient,
+                question_policy_mode: pending.mode,
+                question_policy_version: pending.policyVersion,
+                decision_action: pending.action,
+                decision_ids: decisionIds,
+                decision_count: decisionIds.length,
+                applied_count: applied,
+                failed_count: failed,
+                resolution_source: "policy_timeout",
+                timeout_seconds_applied: pending.timeoutSeconds,
+                failures,
+            },
+        });
+    };
+    const armQuestionAutoAnswerTimer = (key, pending, delaySeconds) => {
+        if (pending.timer) {
+            clearTimeout(pending.timer);
+        }
+        pending.timer = setTimeout(() => {
+            void (async () => {
+                try {
+                    await emitActivitySafe({
+                        initiativeId: pending.initiativeId,
+                        runId: pending.sourceRunId,
+                        correlationId: pending.sourceRunId,
+                        phase: "review",
+                        level: "info",
+                        progressPct: 100,
+                        nextStep: "Applying configured decision action sequentially.",
+                        message: "Question timeout reached; applying auto-answer policy.",
+                        metadata: {
+                            event: "question_timeout_started",
+                            action_type: normalizeActivityActionType("question_timeout_started"),
+                            action_phase: normalizeActivityActionPhase("review"),
+                            initiative_id: pending.initiativeId,
+                            workstream_id: pending.workstreamId,
+                            source_run_id: pending.sourceRunId,
+                            source_client: pending.sourceClient,
+                            decision_ids: pending.decisionIds,
+                            decision_count: pending.decisionIds.length,
+                            decision_action: pending.action,
+                            question_policy_mode: pending.mode,
+                            question_policy_version: pending.policyVersion,
+                            timeout_seconds_applied: pending.timeoutSeconds,
+                        },
+                    });
+                    await processQuestionAutoAnswer(key, pending);
+                }
+                catch (err) {
+                    await emitActivitySafe({
+                        initiativeId: pending.initiativeId,
+                        runId: pending.sourceRunId,
+                        correlationId: pending.sourceRunId,
+                        phase: "blocked",
+                        level: "warn",
+                        progressPct: 100,
+                        nextStep: "Review and resolve the queued question manually.",
+                        message: "Question auto-answer failed before apply.",
+                        metadata: {
+                            event: "question_answer_failed",
+                            action_type: normalizeActivityActionType("question_answer_failed"),
+                            action_phase: normalizeActivityActionPhase("blocked"),
+                            initiative_id: pending.initiativeId,
+                            workstream_id: pending.workstreamId,
+                            source_run_id: pending.sourceRunId,
+                            source_client: pending.sourceClient,
+                            decision_ids: pending.decisionIds,
+                            decision_count: pending.decisionIds.length,
+                            decision_action: pending.action,
+                            failed_count: pending.decisionIds.length,
+                            resolution_source: "policy_timeout",
+                            timeout_seconds_applied: pending.timeoutSeconds,
+                            question_policy_mode: pending.mode,
+                            question_policy_version: pending.policyVersion,
+                            error: safeErrorMessage(err),
+                        },
+                    });
+                }
+            })();
+        }, delaySeconds * 1_000);
+        pending.timer.unref?.();
+    };
+    const scheduleQuestionAutoAnswer = async (input) => {
+        const decisionIds = dedupeStrings(input.decisionIds
+            .map((entry) => (entry ?? "").trim())
+            .filter(Boolean));
+        if (decisionIds.length === 0)
+            return;
+        const policy = resolveQuestionPolicy(input.initiativeId, input.workstreamId);
+        await emitActivitySafe({
+            initiativeId: input.initiativeId,
+            runId: input.sourceRunId,
+            correlationId: input.sourceRunId,
+            phase: "review",
+            level: "info",
+            progressPct: 0,
+            nextStep: input.blocking
+                ? "Blocking question requires human review."
+                : `Auto-answer in ${policy.timeoutSeconds}s unless human responds.`,
+            message: input.blocking
+                ? "Blocking question surfaced for human decision."
+                : "Question surfaced and queued for timeout policy.",
+            metadata: {
+                event: "question_asked",
+                action_type: normalizeActivityActionType("question_asked"),
+                action_phase: normalizeActivityActionPhase("review"),
+                initiative_id: input.initiativeId,
+                workstream_id: input.workstreamId,
+                source_run_id: input.sourceRunId,
+                source_client: input.sourceClient,
+                decision_ids: decisionIds,
+                decision_count: decisionIds.length,
+                blocking: input.blocking,
+                question_policy_mode: policy.mode,
+                question_policy_version: policy.policyVersion,
+                timeout_seconds_applied: policy.timeoutSeconds,
+            },
+        });
+        if (input.blocking) {
+            await emitActivitySafe({
+                initiativeId: input.initiativeId,
+                runId: input.sourceRunId,
+                correlationId: input.sourceRunId,
+                phase: "blocked",
+                level: "info",
+                progressPct: 0,
+                nextStep: policy.blockingBehavior === "guarded_auto_resolve_then_human" &&
+                    decisionAutoResolveGuardedEnabled
+                    ? "Awaiting guarded remediation and/or human decision."
+                    : "Awaiting human decision response.",
+                message: policy.blockingBehavior === "guarded_auto_resolve_then_human" &&
+                    decisionAutoResolveGuardedEnabled
+                    ? "Blocking question requires human decision after guarded remediation."
+                    : "Blocking question requires human decision.",
+                metadata: {
+                    event: "review_item_created",
+                    action_type: normalizeActivityActionType("review_item_created"),
+                    action_phase: normalizeActivityActionPhase("blocked"),
+                    initiative_id: input.initiativeId,
+                    workstream_id: input.workstreamId,
+                    source_run_id: input.sourceRunId,
+                    source_client: input.sourceClient,
+                    decision_ids: decisionIds,
+                    decision_count: decisionIds.length,
+                    blocking: true,
+                    reason: "blocking_question_requires_human",
+                    question_policy_mode: policy.mode,
+                    question_policy_version: policy.policyVersion,
+                    question_blocking_behavior: policy.blockingBehavior,
+                },
+            });
+            return;
+        }
+        if (!policy.enabled) {
+            await emitActivitySafe({
+                initiativeId: input.initiativeId,
+                runId: input.sourceRunId,
+                correlationId: input.sourceRunId,
+                phase: "review",
+                level: "info",
+                progressPct: 0,
+                nextStep: "Awaiting human decision response.",
+                message: "Question auto-answer is disabled for this agent policy.",
+                metadata: {
+                    event: "review_item_created",
+                    action_type: normalizeActivityActionType("review_item_created"),
+                    action_phase: normalizeActivityActionPhase("review"),
+                    initiative_id: input.initiativeId,
+                    workstream_id: input.workstreamId,
+                    source_run_id: input.sourceRunId,
+                    source_client: input.sourceClient,
+                    decision_ids: decisionIds,
+                    reason: "policy_disabled",
+                    question_policy_mode: policy.mode,
+                    question_policy_version: policy.policyVersion,
+                },
+            });
+            return;
+        }
+        const key = questionScopeKey(input.initiativeId, input.workstreamId);
+        const dueAtEpoch = Date.now() + policy.timeoutSeconds * 1_000;
+        const existing = pendingQuestionAutoAnswerByScope.get(key);
+        if (existing) {
+            existing.decisionIds = dedupeStrings([...existing.decisionIds, ...decisionIds]);
+            existing.sourceRunId = input.sourceRunId ?? existing.sourceRunId;
+            existing.sourceClient = input.sourceClient || existing.sourceClient;
+            existing.action = policy.action;
+            existing.mode = policy.mode;
+            existing.policyVersion = policy.policyVersion;
+            existing.timeoutSeconds = policy.timeoutSeconds;
+            existing.dueAt = new Date(dueAtEpoch).toISOString();
+            armQuestionAutoAnswerTimer(key, existing, policy.timeoutSeconds);
+            await emitActivitySafe({
+                initiativeId: input.initiativeId,
+                runId: input.sourceRunId,
+                correlationId: input.sourceRunId,
+                phase: "review",
+                level: "info",
+                progressPct: 0,
+                nextStep: `Auto-answer in ${policy.timeoutSeconds}s unless human responds.`,
+                message: "Extended timeout for queued unanswered decision(s).",
+                metadata: {
+                    event: "question_timeout_started",
+                    action_type: normalizeActivityActionType("question_timeout_started"),
+                    action_phase: normalizeActivityActionPhase("review"),
+                    initiative_id: input.initiativeId,
+                    workstream_id: input.workstreamId,
+                    source_run_id: input.sourceRunId,
+                    source_client: input.sourceClient,
+                    decision_ids: existing.decisionIds,
+                    decision_count: existing.decisionIds.length,
+                    decision_action: existing.action,
+                    timeout_seconds_applied: policy.timeoutSeconds,
+                    question_policy_mode: policy.mode,
+                    question_policy_version: policy.policyVersion,
+                    due_at: existing.dueAt,
+                    reason: input.reason,
+                },
+            });
+            return;
+        }
+        const pending = {
+            key,
+            initiativeId: input.initiativeId ?? "",
+            workstreamId: input.workstreamId ?? null,
+            sourceRunId: input.sourceRunId ?? null,
+            sourceClient: input.sourceClient,
+            action: policy.action,
+            mode: policy.mode,
+            policyVersion: policy.policyVersion,
+            timeoutSeconds: policy.timeoutSeconds,
+            dueAt: new Date(dueAtEpoch).toISOString(),
+            timer: null,
+            decisionIds,
+        };
+        armQuestionAutoAnswerTimer(key, pending, policy.timeoutSeconds);
+        pendingQuestionAutoAnswerByScope.set(key, pending);
+        await emitActivitySafe({
+            initiativeId: input.initiativeId,
+            runId: input.sourceRunId,
+            correlationId: input.sourceRunId,
+            phase: "review",
+            level: "info",
+            progressPct: 0,
+            nextStep: `Auto-answer in ${policy.timeoutSeconds}s unless human responds.`,
+            message: "Queued unanswered decision(s) for timeout auto-answer.",
+            metadata: {
+                event: "question_timeout_started",
+                action_type: normalizeActivityActionType("question_timeout_started"),
+                action_phase: normalizeActivityActionPhase("review"),
+                initiative_id: input.initiativeId,
+                workstream_id: input.workstreamId,
+                source_run_id: input.sourceRunId,
+                source_client: input.sourceClient,
+                decision_ids: decisionIds,
+                decision_count: decisionIds.length,
+                decision_action: policy.action,
+                timeout_seconds_applied: policy.timeoutSeconds,
+                question_policy_mode: policy.mode,
+                question_policy_version: policy.policyVersion,
+                due_at: pending.dueAt,
+                reason: input.reason,
+            },
+        });
+    };
     const requestDecisionQueued = async (input) => {
+        const asRecord = (value) => {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return null;
+            return value;
+        };
+        const normalizeId = (value) => {
+            if (typeof value !== "string")
+                return null;
+            const trimmed = value.trim();
+            return trimmed.length > 0 ? trimmed : null;
+        };
+        const normalizeLower = (value) => {
+            if (typeof value !== "string")
+                return "";
+            return value.trim().toLowerCase();
+        };
+        const recoverQueuedDecisionIds = async (recoverInput) => {
+            try {
+                const pending = await client.getLiveDecisions({ status: "pending", limit: 100 });
+                const rows = Array.isArray(pending?.decisions) ? pending.decisions : [];
+                const wantedTitle = normalizeLower(recoverInput.title);
+                const wantedRunId = normalizeLower(recoverInput.sourceRunId ?? "");
+                const wantedWorkstreamId = normalizeLower(recoverInput.workstreamId ?? "");
+                const recentThreshold = Date.now() - 10 * 60 * 1_000;
+                const ids = [];
+                const seen = new Set();
+                for (const row of rows) {
+                    const record = asRecord(row);
+                    if (!record)
+                        continue;
+                    const id = normalizeId(record.id) ??
+                        normalizeId(record.entity_id) ??
+                        normalizeId(record.decision_id);
+                    if (!id || seen.has(id))
+                        continue;
+                    const metadata = asRecord(record.metadata);
+                    const sourceRef = asRecord(record.source_ref) ?? asRecord(metadata?.source_ref);
+                    const rowWorkstreamId = normalizeLower(record.workstream_id) ||
+                        normalizeLower(record.workstreamId) ||
+                        normalizeLower(metadata?.source_stream_id) ||
+                        normalizeLower(sourceRef?.workstream_id) ||
+                        normalizeLower(sourceRef?.stream_id);
+                    const rowRunId = normalizeLower(record.source_run_id) ||
+                        normalizeLower(record.sourceRunId) ||
+                        normalizeLower(metadata?.run_id) ||
+                        normalizeLower(metadata?.correlation_id) ||
+                        normalizeLower(sourceRef?.run_id);
+                    const rowTitle = normalizeLower(record.title) || normalizeLower(metadata?.title);
+                    const updatedAtRaw = normalizeId(record.updated_at) ?? normalizeId(record.created_at);
+                    const updatedAtEpoch = updatedAtRaw ? Date.parse(updatedAtRaw) : NaN;
+                    const recentEnough = !Number.isFinite(updatedAtEpoch) || updatedAtEpoch >= recentThreshold;
+                    const workstreamMatches = !wantedWorkstreamId || rowWorkstreamId === wantedWorkstreamId;
+                    const runMatches = Boolean(wantedRunId) && rowRunId === wantedRunId;
+                    const titleMatches = Boolean(wantedTitle) && rowTitle === wantedTitle;
+                    if (!workstreamMatches)
+                        continue;
+                    if (!(runMatches || (titleMatches && recentEnough)))
+                        continue;
+                    seen.add(id);
+                    ids.push(id);
+                }
+                return ids;
+            }
+            catch {
+                return [];
+            }
+        };
         const inferredRunId = (typeof input.sourceRunId === "string" && input.sourceRunId.trim().length > 0
             ? input.sourceRunId.trim()
             : null) ??
@@ -57,6 +594,18 @@ export function createAutoContinueEngine(deps) {
         const sourceRefBase = input.sourceRef && typeof input.sourceRef === "object" && !Array.isArray(input.sourceRef)
             ? input.sourceRef
             : {};
+        const metadataBase = input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata)
+            ? input.metadata
+            : {};
+        const metadataSourceClient = (typeof metadataBase.source_client === "string" && metadataBase.source_client.trim().length > 0
+            ? metadataBase.source_client.trim()
+            : null) ??
+            (typeof metadataBase.sourceClient === "string" && metadataBase.sourceClient.trim().length > 0
+                ? metadataBase.sourceClient.trim()
+                : null);
+        const inferredSourceClient = normalizeRuntimeSourceClient(metadataSourceClient ??
+            process.env.ORGX_AUTOPILOT_EXECUTOR ??
+            process.env.ORGX_AUTOPILOT_WORKER_KIND);
         const normalizedInput = {
             ...input,
             sourceRunId: inferredRunId,
@@ -68,25 +617,65 @@ export function createAutoContinueEngine(deps) {
                 session_id: sourceRefBase.session_id ?? inferredSessionId,
                 stream_id: sourceRefBase.stream_id ?? inferredStreamId,
                 workstream_id: sourceRefBase.workstream_id ?? input.workstreamId ?? null,
+                source_client: sourceRefBase.source_client ??
+                    sourceRefBase.sourceClient ??
+                    inferredSourceClient,
             },
             metadata: {
-                ...(input.metadata ?? {}),
+                ...metadataBase,
                 source_system: input.sourceSystem ?? null,
                 conflict_source: input.conflictSource ?? null,
+                source_client: metadataBase.source_client ??
+                    metadataBase.sourceClient ??
+                    inferredSourceClient,
             },
         };
+        const linkedSlice = inferredRunId ? autoContinueSliceRuns.get(inferredRunId) ?? null : null;
+        const sourceClientFromInput = typeof normalizedInput.metadata?.source_client === "string"
+            ? normalizedInput.metadata.source_client
+            : null;
+        const sourceClient = sourceClientFromInput ??
+            linkedSlice?.sourceClient ??
+            "unknown";
+        const scopedWorkstreamId = ((typeof normalizedInput.workstreamId === "string" &&
+            normalizedInput.workstreamId.trim().length > 0
+            ? normalizedInput.workstreamId.trim()
+            : null) ??
+            inferredStreamId ??
+            linkedSlice?.workstreamId ??
+            null);
         const result = await requestDecisionSafe(normalizedInput);
         if (typeof result === "boolean") {
             return { queued: result, decisionIds: [] };
         }
         if (result && typeof result === "object" && "queued" in result) {
             const record = result;
-            const decisionIds = Array.isArray(record.decisionIds)
+            let decisionIds = Array.isArray(record.decisionIds)
                 ? record.decisionIds
                     .filter((entry) => typeof entry === "string")
                     .map((entry) => entry.trim())
                     .filter(Boolean)
                 : [];
+            if (Boolean(record.queued) && decisionIds.length === 0) {
+                decisionIds = await recoverQueuedDecisionIds({
+                    title: normalizedInput.title,
+                    sourceRunId: inferredRunId,
+                    workstreamId: scopedWorkstreamId,
+                });
+            }
+            if (Boolean(record.queued) && decisionIds.length > 0) {
+                await scheduleQuestionAutoAnswer({
+                    initiativeId: normalizedInput.initiativeId,
+                    workstreamId: scopedWorkstreamId,
+                    sourceRunId: inferredRunId,
+                    sourceClient,
+                    decisionIds,
+                    blocking: Boolean(normalizedInput.blocking),
+                    reason: typeof normalizedInput.conflictSource === "string"
+                        ? normalizedInput.conflictSource
+                        : null,
+                });
+            }
             return {
                 queued: Boolean(record.queued),
                 decisionIds,
@@ -152,6 +741,20 @@ export function createAutoContinueEngine(deps) {
                 return "status_updates_applied";
             if (eventName.includes("artifact_registered"))
                 return "artifact_registered";
+            if (eventName.includes("question_asked"))
+                return "question_asked";
+            if (eventName.includes("question_timeout_started"))
+                return "question_timeout_started";
+            if (eventName.includes("question_auto_answered"))
+                return "question_auto_answered";
+            if (eventName.includes("question_answer_applied"))
+                return "question_answer_applied";
+            if (eventName.includes("question_answer_failed"))
+                return "question_answer_failed";
+            if (eventName.includes("review_item_created"))
+                return "review_item_created";
+            if (eventName.includes("review_item_resolved"))
+                return "review_item_resolved";
             if (eventName.includes("decision_requested"))
                 return "decision_requested";
             if (eventName.includes("decision_resolved"))
@@ -229,6 +832,8 @@ export function createAutoContinueEngine(deps) {
             run_id: input.slice?.runId ?? null,
             slice_run_id: input.slice?.runId ?? null,
             correlation_id: input.slice?.runId ?? null,
+            source_client: input.slice?.sourceClient ?? "unknown",
+            runtime_client: input.slice?.sourceClient ?? "unknown",
             workstream_id: workstreamId,
             workstream_title: input.workstreamTitle ?? input.slice?.workstreamTitle ?? null,
             task_id: taskId,
@@ -266,7 +871,6 @@ export function createAutoContinueEngine(deps) {
             ...(input.extra ?? {}),
         };
     };
-    const autoContinueSliceRuns = new Map();
     // Keep child handles alive so stdout/stderr capture remains reliable even when the process is detached.
     const autoContinueSliceChildren = new Map();
     const autoContinueSliceLastHeartbeatMs = new Map();
@@ -765,6 +1369,14 @@ export function createAutoContinueEngine(deps) {
         await updateInitiativeMetadata(input.initiativeId, patch);
     }
     async function stopAutoContinueRun(input) {
+        const decisionRequired = input.reason === "blocked" && input.decisionRequired === true;
+        const decisionIds = Array.isArray(input.decisionIds)
+            ? input.decisionIds
+                .filter((entry) => typeof entry === "string")
+                .map((entry) => entry.trim())
+                .filter(Boolean)
+            : [];
+        const preserveQuestionAutoAnswerState = input.reason === "blocked" && decisionRequired && decisionIds.length > 0;
         const now = new Date().toISOString();
         ensureRunInternals(input.run);
         const activeRunIds = listActiveSliceRunIds(input.run);
@@ -791,6 +1403,9 @@ export function createAutoContinueEngine(deps) {
         if (input.error)
             input.run.lastError = input.error;
         clearSpawnGuardRetryStateForInitiative(input.run.initiativeId);
+        if (!preserveQuestionAutoAnswerState) {
+            clearQuestionAutoAnswerStateForInitiative(input.run.initiativeId);
+        }
         for (const runId of activeRunIds) {
             clearAutoContinueSliceTransientState(runId);
         }
@@ -820,13 +1435,6 @@ export function createAutoContinueEngine(deps) {
             ? input.run.allowedWorkstreamIds[0]
             : null;
         const scopeSuffix = scopedWorkstreamId ? ` [workstream ${scopedWorkstreamId}]` : "";
-        const decisionRequired = input.reason === "blocked" && input.decisionRequired === true;
-        const decisionIds = Array.isArray(input.decisionIds)
-            ? input.decisionIds
-                .filter((entry) => typeof entry === "string")
-                .map((entry) => entry.trim())
-                .filter(Boolean)
-            : [];
         const budgetValue = typeof input.run.tokenBudget === "number" ? input.run.tokenBudget : "unbounded";
         const message = input.reason === "completed"
             ? `Autopilot stopped: current dispatch scope completed${scopeSuffix}.`
@@ -1291,13 +1899,11 @@ export function createAutoContinueEngine(deps) {
                         item?.blocking === true);
                 };
                 const decisions = allDecisions.filter((item) => !isParserSyntheticFallbackDecision(item));
-                const blockingDecisionCount = decisions.filter((item) => typeof item.blocking === "boolean" ? item.blocking : defaultDecisionBlocking).length;
-                const nonBlockingDecisionCount = Math.max(0, decisions.length - blockingDecisionCount);
-                const effectiveParsedStatus = parsedStatus === "completed" && blockingDecisionCount > 0
+                const normalizedBlockingDecisionCount = allDecisions.filter((item) => typeof item.blocking === "boolean" ? item.blocking : defaultDecisionBlocking).length;
+                const normalizedNonBlockingDecisionCount = Math.max(0, allDecisions.length - normalizedBlockingDecisionCount);
+                const effectiveParsedStatus = parsedStatus === "completed" && normalizedBlockingDecisionCount > 0
                     ? "needs_decision"
-                    : parsedStatus === "needs_decision" && blockingDecisionCount === 0
-                        ? "completed"
-                        : parsedStatus;
+                    : parsedStatus;
                 slice.status =
                     effectiveParsedStatus === "completed"
                         ? "completed"
@@ -1574,9 +2180,9 @@ export function createAutoContinueEngine(deps) {
                             requested_by_agent_name: run.agentName,
                             status: effectiveParsedStatus,
                             artifacts: artifacts.length,
-                            decisions: decisions.length,
-                            blocking_decisions: blockingDecisionCount,
-                            non_blocking_decisions: nonBlockingDecisionCount,
+                            decisions: allDecisions.length,
+                            blocking_decisions: normalizedBlockingDecisionCount,
+                            non_blocking_decisions: normalizedNonBlockingDecisionCount,
                             status_updates: statusUpdateResult.applied,
                             status_updates_buffered: statusUpdateResult.buffered,
                             reported_skill_evidence_count: skillEvidence.length,
@@ -1665,13 +2271,13 @@ export function createAutoContinueEngine(deps) {
                         parsed_status: effectiveParsedStatus,
                         has_output: Boolean(parsed),
                         artifacts: artifacts.length,
-                        decisions: decisions.length,
-                        blocking_decisions: blockingDecisionCount,
-                        non_blocking_decisions: nonBlockingDecisionCount,
+                        decisions: allDecisions.length,
+                        blocking_decisions: normalizedBlockingDecisionCount,
+                        non_blocking_decisions: normalizedNonBlockingDecisionCount,
                         decision_ids: decisionIds,
                         blocking_decision_ids: Array.from(new Set(blockingDecisionIds)),
                         non_blocking_decision_ids: Array.from(new Set(nonBlockingDecisionIds)),
-                        decision_required: blockingDecisionQueued,
+                        decision_required: blockingDecisionQueued || effectiveParsedStatus === "needs_decision",
                         status_updates_applied: statusUpdateResult.applied,
                         status_updates_buffered: statusUpdateResult.buffered,
                         reported_skill_evidence_count: skillEvidence.length,
@@ -2736,6 +3342,7 @@ export function createAutoContinueEngine(deps) {
         // Try server KickoffContext (includes team context, acceptance criteria, etc.)
         let prompt;
         let kickoffContextHash = null;
+        let kickoffRuntimeSettings = null;
         if (fetchKickoffContextSafeFn && renderKickoffMessageFn) {
             let kickoff = null;
             try {
@@ -2752,6 +3359,7 @@ export function createAutoContinueEngine(deps) {
                 // best effort: fall back to local prompt
             }
             if (kickoff) {
+                kickoffRuntimeSettings = kickoff.runtime_settings ?? null;
                 const rendered = renderKickoffMessageFn({
                     baseMessage: `Execute workstream slice for ${workstreamTitle ?? selectedWorkstreamId}`,
                     kickoff,
@@ -2797,6 +3405,7 @@ export function createAutoContinueEngine(deps) {
                 schemaPath,
             });
         }
+        questionAutoAnswerPolicyByScope.set(questionScopeKey(run.initiativeId, selectedWorkstreamId), normalizeQuestionAutoAnswerPolicy(kickoffRuntimeSettings));
         // Append per-scope directive for milestone/workstream scopes.
         if (run.scope !== "task") {
             const msNodes = scopeMilestoneIds
@@ -3210,8 +3819,13 @@ export function createAutoContinueEngine(deps) {
                         if (decisionIsBlocking(record))
                             continue;
                         const autoApprovalNote = "Auto-approved by OrgX auto-fix (non-blocking follow-up decision).";
+                        const autoApprovalSourceClient = normalizeRuntimeSourceClient(process.env.ORGX_AUTOPILOT_EXECUTOR ?? process.env.ORGX_AUTOPILOT_WORKER_KIND);
                         if (typeof client.decideDecision === "function") {
-                            await client.decideDecision(decisionId, "approve", { note: autoApprovalNote });
+                            await client.decideDecision(decisionId, "approve", {
+                                note: autoApprovalNote,
+                                source_client: autoApprovalSourceClient,
+                                sourceClient: autoApprovalSourceClient,
+                            });
                         }
                         else {
                             await client.updateEntity("decision", decisionId, {