@tea-agent/loop-agent 0.20.1-beta.0 → 0.21.0

package/dist/executors/pi-sdk-executor.js

@@ -1,6 +1,6 @@
 import { appendFile, mkdir } from 'node:fs/promises';
 import path from 'node:path';
-import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from './pi-executor.js';
+import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from './pi-executor.js';
 import { serializeSessionEvent } from './pi-event-serializer.js';
 let sdkSessionFactoryOverride;
 let sdkImportOverrideForTests;
@@ -169,6 +169,21 @@ export function shouldPersistSessionEvent(event) {
     }
     return true;
 }
+function classifySdkActivityKind(event) {
+    if (!event || typeof event !== 'object')
+        return 'provider';
+    const type = typeof event.type === 'string'
+        ? String(event.type)
+        : '';
+    if (type === 'tool_start' || type === 'tool_end'
+        || type === 'tool_execution_start' || type === 'tool_execution_end') {
+        return 'tool';
+    }
+    if (type === 'thinking_delta' || type === 'message_update') {
+        return null;
+    }
+    return 'provider';
+}
 function createSessionEventAppender(filePath, onSessionEvent) {
     let chain = Promise.resolve();
     let dirEnsured = false;
@@ -181,6 +196,9 @@ function createSessionEventAppender(filePath, onSessionEvent) {
                         dirEnsured = true;
                     }
                     await appendFile(filePath, `${line}\n`, 'utf-8');
+                    // Only after successful persistence: surface the persisted session event.
+                    // Transport activity is reported synchronously by the subscription so
+                    // filtered deltas and slow disk writes cannot trip the stall watchdog.
                     onSessionEvent?.(line, event);
                 }
                 catch {
@@ -271,6 +289,8 @@ export async function executeSingleSdkAttempt(options) {
         ? `${modelConfig.provider}/${modelConfig.model}`
         : modelConfig.model ?? 'default';
     const timeoutMs = options.timeoutMs ?? modelConfig.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const stallTimeoutMs = options.stallTimeoutMs ?? DEFAULT_STALL_TIMEOUT_MS;
+    const abortGraceMs = options.abortGraceMs ?? DEFAULT_ABORT_GRACE_MS;
     const piSdkArgs = [
         '--provider', modelConfig.provider ?? '(default)',
         '--model', modelConfig.model ?? '(default)',
@@ -282,15 +302,46 @@ export async function executeSingleSdkAttempt(options) {
     ];
     const startedAt = Date.now();
     let timedOut = false;
+    let terminationConfirmed = true;
     let stderr = '';
     const stdoutPreview = new BoundedTextPreview('stdout');
     const stdoutCollector = createPiJsonlStreamCollector();
     const usageSamples = [];
     let session;
+    let unsubscribe;
     let timeoutHandle;
+    let stallHandle;
+    let disposeAttempted = false;
     const sessionEventAppender = options.sessionEventsPath
         ? createSessionEventAppender(options.sessionEventsPath, options.onSessionEvent)
         : undefined;
+    const appendStderr = (message) => {
+        stderr = stderr ? `${stderr}\n${message}` : message;
+    };
+    const runSessionActionWithGrace = async (label, action) => {
+        let graceHandle;
+        const outcome = await Promise.race([
+            Promise.resolve()
+                .then(action)
+                .then(() => ({ ok: true }))
+                .catch((error) => ({ ok: false, error })),
+            new Promise((resolve) => {
+                graceHandle = setTimeout(() => resolve({ ok: false, timedOut: true }), abortGraceMs);
+            }),
+        ]);
+        if (graceHandle)
+            clearTimeout(graceHandle);
+        if (outcome.ok)
+            return true;
+        if ('timedOut' in outcome) {
+            appendStderr(`pi SDK ${label} was not confirmed within ${abortGraceMs}ms`);
+        }
+        else {
+            const message = outcome.error instanceof Error ? outcome.error.message : String(outcome.error);
+            appendStderr(`pi SDK ${label} failed: ${message}`);
+        }
+        return false;
+    };
     try {
         const createSession = await resolveSdkSessionFactory(options.reuseScope);
         session = await createSession({
@@ -301,7 +352,32 @@ export async function executeSingleSdkAttempt(options) {
             model: modelConfig.model,
             thinking: modelConfig.thinking,
         });
-        const unsubscribe = session.subscribe((event) => {
+        let resolveStall;
+        const stallPromise = stallTimeoutMs > 0
+            ? new Promise((resolve) => {
+                resolveStall = resolve;
+            })
+            : null;
+        const armStallWatchdog = () => {
+            if (!stallPromise || !resolveStall)
+                return;
+            if (stallHandle)
+                clearTimeout(stallHandle);
+            stallHandle = setTimeout(() => resolveStall?.('stall'), stallTimeoutMs);
+        };
+        unsubscribe = session.subscribe((event) => {
+            // Every real SDK event proves transport activity, including noisy deltas
+            // intentionally excluded from persisted JSONL and meaningful DAG progress.
+            armStallWatchdog();
+            const activityKind = classifySdkActivityKind(event);
+            if (activityKind) {
+                try {
+                    options.onActivity?.({ kind: activityKind, at: new Date().toISOString() });
+                }
+                catch {
+                    // best-effort: activity must never change Pi result
+                }
+            }
             const usageSample = extractSdkUsageSample(event);
             if (usageSample)
                 usageSamples.push(usageSample);
@@ -317,44 +393,44 @@ export async function executeSingleSdkAttempt(options) {
             ? `${filePrefix}\n${options.userMessage}`
             : options.userMessage;
         const promptPromise = session.prompt(promptMessage);
+        armStallWatchdog();
         const timeoutPromise = timeoutMs > 0
             ? new Promise((resolve) => {
                 timeoutHandle = setTimeout(() => {
-                    timedOut = true;
-                    void session?.abort();
-                    resolve('timeout');
+                    resolve('absolute-timeout');
                 }, timeoutMs);
             })
             : null;
-        if (timeoutPromise) {
-            const raced = await Promise.race([
-                promptPromise.then(() => 'done'),
-                timeoutPromise,
-            ]);
-            if (raced === 'timeout') {
-                stderr = `pi SDK step timed out after ${timeoutMs}ms`;
-            }
+        const raced = await Promise.race([
+            promptPromise.then(() => 'done'),
+            ...(timeoutPromise ? [timeoutPromise] : []),
+            ...(stallPromise ? [stallPromise] : []),
+        ]);
+        if (raced !== 'done') {
+            timedOut = true;
+            appendStderr(raced === 'stall'
+                ? `pi SDK step stalled after ${stallTimeoutMs}ms with no provider activity`
+                : `pi SDK step timed out after ${timeoutMs}ms`);
+            const abortConfirmed = await runSessionActionWithGrace('abort', () => session.abort());
+            disposeAttempted = true;
+            const disposeConfirmed = await runSessionActionWithGrace('dispose', () => session.dispose());
+            terminationConfirmed = abortConfirmed && disposeConfirmed;
         }
-        else {
-            await promptPromise;
-        }
-        unsubscribe();
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        stderr = stderr ? `${stderr}\n${message}` : message;
+        appendStderr(message);
     }
     finally {
         if (timeoutHandle)
             clearTimeout(timeoutHandle);
-        if (session) {
-            try {
-                await session.dispose();
-            }
-            catch (disposeError) {
-                const message = disposeError instanceof Error ? disposeError.message : String(disposeError);
-                stderr = stderr ? `${stderr}\n${message}` : message;
-            }
+        if (stallHandle)
+            clearTimeout(stallHandle);
+        unsubscribe?.();
+        if (session && !disposeAttempted) {
+            disposeAttempted = true;
+            const disposeConfirmed = await runSessionActionWithGrace('dispose', () => session.dispose());
+            terminationConfirmed = terminationConfirmed && disposeConfirmed;
         }
         if (sessionEventAppender) {
             try {
@@ -378,14 +454,14 @@ export async function executeSingleSdkAttempt(options) {
         ? collected.parsedEvents
         : fallbackParsed?.parsedEvents ?? 0;
     const tokensUsed = aggregateSdkTokenUsage(usageSamples);
-    const failureCategory = classifyPiFailure({
+    const failureCategory = terminationConfirmed ? classifyPiFailure({
         assistantText,
         exitCode: timedOut ? 1 : stderr ? 1 : 0,
         outputTooLarge: collected.outputTooLarge,
         stderr,
         stdout,
         timedOut,
-    });
+    }) : 'termination-unconfirmed';
     return {
         assistantText,
         backend: 'sdk',
@@ -394,7 +470,7 @@ export async function executeSingleSdkAttempt(options) {
         exitCode: timedOut || stderr ? 1 : 0,
         failureCategory,
         modelDisplay,
-        ok: !timedOut && !stderr && assistantText.length > 0 && !collected.outputTooLarge,
+        ok: terminationConfirmed && !timedOut && !stderr && assistantText.length > 0 && !collected.outputTooLarge,
         parsedEvents,
         stderr,
         stdout,

package/dist/executors/shell-executor.js

@@ -17,7 +17,7 @@ import { formatFrontendReviewContextStdout, runFrontendReviewContextGate, } from
 import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
 import { materializeBackendTestResultFromRunDir, parseJunitXml } from "../workflows/dag/backend-test-result-contract.js";
-import { collectBackendTestHumanCaseCatalog, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
+import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, hasBlockingBackendMarkdownSafetyFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
 import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
@@ -304,6 +304,14 @@ async function runShellWriteGuard(input) {
         forbiddenPaths: input.task.forbiddenPaths,
     });
 }
+async function readRequiredRunReport(reportsDir, filename) {
+    try {
+        return await readFile(path.join(reportsDir, filename), "utf8");
+    }
+    catch {
+        throw new Error(`missing required upstream report: reports/${filename}`);
+    }
+}
 async function executeBackendTestPipeline(input, meta) {
     const pipeline = input.task.shell?.backendTestPipeline;
     const started = Date.now();
@@ -332,22 +340,54 @@ async function executeBackendTestPipeline(input, meta) {
                 meta.spec.objective ?? "",
                 ...(meta.spec.successCriteria ?? []),
             ]);
-            const report = await validateBackendMarkdownCases({
-                workspaceRoot: input.cwd,
-                environmentMarkdown,
-                requiredRequirementIds,
-                sourceBinding: meta.spec.sourceBinding,
-            });
+            let report;
+            try {
+                report = await validateBackendMarkdownCases({
+                    workspaceRoot: input.cwd,
+                    environmentMarkdown,
+                    requiredRequirementIds,
+                    sourceBinding: meta.spec.sourceBinding,
+                });
+            }
+            catch (error) {
+                report = `# Backend Markdown Case Validation\n\n## Status\n\nFAIL\n\n## Findings\n\n- Validator could not complete: ${error instanceof Error ? error.message : String(error)}\n`;
+            }
             const reportPath = await writeRunReport(meta.runDir, "backend-md-case-validation.md", report);
             outputs.push(`caseValidation=${reportPath}`, report);
+            if (hasBlockingBackendMarkdownSafetyFindings(report)) {
+                return {
+                    ok: false,
+                    stdout: outputs.join("\n"),
+                    stderr: "backend Markdown safety gate blocked: secret-shaped values detected",
+                    failureCategory: "invalid-output",
+                    durationMs: Date.now() - started,
+                };
+            }
         }
         else if (pipeline === "markdown-traceability") {
-            const report = await validateBackendMarkdownTraceability(input.cwd);
+            let report;
+            try {
+                report = await validateBackendMarkdownTraceability(input.cwd);
+            }
+            catch (error) {
+                report = `# Backend Test Traceability\n\n## Status\n\nFAIL\n\n## Findings\n\n- Traceability validation could not complete: ${error instanceof Error ? error.message : String(error)}\n`;
+            }
             const reportPath = await writeRunReport(meta.runDir, "backend-test-traceability.md", report);
             outputs.push(`traceability=${reportPath}`, report);
         }
         else if (pipeline === "markdown-execute-html") {
-            const results = await executePipelineCommands(input, meta);
+            const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
+            const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+            const pytestTargets = mappedScripts.map(shellQuote).join(" ");
+            const pytestCommand = [
+                'mkdir -p "${HARNESS_DAG_RUN_DIR}/reports"',
+                `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 python -m pytest ${pytestTargets} -v -p no:cacheprovider -o junit_logging=all -o junit_log_passing_tests=true --junitxml="\${HARNESS_DAG_RUN_DIR}/reports/backend-test.junit.xml"`,
+                "STATUS=$?",
+                'printf "%s" "${STATUS}" > "${HARNESS_DAG_RUN_DIR}/reports/backend-test-pytest-exit.txt"',
+                'if { [ "${STATUS}" -eq 0 ] || [ "${STATUS}" -eq 1 ]; } && [ -s "${HARNESS_DAG_RUN_DIR}/reports/backend-test.junit.xml" ]; then exit 0; fi',
+                'exit "${STATUS}"',
+            ].join("; ");
+            const results = await executePipelineCommands(input, meta, [pytestCommand]);
             if (!results.every((result) => result.ok)) {
                 const failure = results.find((result) => !result.ok);
                 return { ok: false, stdout: results.map((result) => result.stdout).join("\n"), stderr: failure.stderr, failureCategory: failure.failureCategory, durationMs: Date.now() - started };
@@ -359,15 +399,18 @@ async function executeBackendTestPipeline(input, meta) {
                 throw new Error(`pytest did not complete with a reportable exit code: ${pytestExitCode}`);
             const parsed = parseJunitXml(junitContent);
             const cases = await collectBackendTestHumanCaseCatalog(input.cwd);
+            const caseValidationSummary = await readRequiredRunReport(reportsDir, "backend-md-case-validation.md");
+            const traceabilitySummary = await readRequiredRunReport(reportsDir, "backend-test-traceability.md");
             const htmlContent = renderBackendTestHtml({
                 title: meta.spec.title,
                 parsed,
                 cases,
                 environmentSummary: await readFile(path.join(reportsDir, "backend-test-environment.md"), "utf8"),
-                traceabilitySummary: await readFile(path.join(reportsDir, "backend-test-traceability.md"), "utf8"),
+                caseValidationSummary,
+                traceabilitySummary,
             });
             const htmlPath = await writeRunReport(meta.runDir, "backend-test.html", htmlContent);
-            const facts = renderBackendTestFacts({ parsed, cases, pytestExitCode, junitRelativePath: "reports/backend-test.junit.xml", htmlRelativePath: "reports/backend-test.html", junitContent, htmlContent });
+            const facts = renderBackendTestFacts({ parsed, cases, pytestExitCode, junitRelativePath: "reports/backend-test.junit.xml", htmlRelativePath: "reports/backend-test.html", junitContent, htmlContent, caseValidationSummary, traceabilitySummary });
             const factsPath = await writeRunReport(meta.runDir, "backend-test-facts.md", facts);
             const sanitizedOutputs = results.map((result) => redactBackendTestOutput(result.stdout));
             outputs.push(...sanitizedOutputs, `html=${htmlPath}`, `facts=${factsPath}`, facts);

package/dist/shared/operator/capabilities.js

@@ -167,6 +167,16 @@ export function buildOperatorCapabilitiesDocument() {
             requiredErrorCodes: ["INVALID_INPUT", "OPERATION_NEEDS_RECONCILE"],
             description: "Repo doctor (registry entry; envelope migration follow-up).",
         },
+        {
+            action: "dagReport",
+            cli: "loop-agent dag report --run-id <runId> --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "DAG run handoff report by run id.",
+        },
         {
             action: "status",
             cli: "loop-agent status <taskId> --json",
@@ -226,6 +236,50 @@ export function buildOperatorCapabilitiesDocument() {
             ],
             description: "Execute reviewed DAG; revalidate binding before writer start.",
         },
+        {
+            action: "dagRerunPlan",
+            cli: "loop-agent dag rerun --run-id <id> --from-node <node> --plan --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
+            description: "Read-only subgraph rerun plan for confirmation (no mutation).",
+        },
+        {
+            action: "dagRerun",
+            cli: "loop-agent dag rerun --run-id <id> --from-node <node> --plan-hash <hash> --request-id <id> --reason <text> --json",
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "BINDING_DRIFT",
+                "INVALID_INPUT",
+            ],
+            description: "Execute continuation run from effective node with confirmed plan hash.",
+        },
+        {
+            action: "standaloneTaskRerun",
+            cli: "loop-agent dag rerun-task --run-id <id> --reason <text> --request-id <id> [--profile auto] [--task-id <id>] --json",
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [...COMMON_MUTATION_ERRORS, "INVALID_INPUT"],
+            description: "Full standalone task regenerate → validate → execute with parent lineage.",
+        },
+        {
+            action: "workerTaskRetry",
+            cli: "agent-worker task retry <task-id> --feature-id <feature-id> --repo . --reason <text>",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [...COMMON_MUTATION_ERRORS, "INVALID_INPUT"],
+            description: "Requeue failed Task Pool task (Failed → Ready) via in-package pool store.",
+        },
     ];
     return {
         schemaVersion: 1,

package/dist/worker/console/index.js

@@ -5,7 +5,7 @@ export { isLoopbackHost } from "./loopback.js";
 export { repoFingerprintV1, normalizeWorktreeRealpath, } from "./repo-fingerprint.js";
 export { buildObserveDeepLink } from "./observe-link.js";
 export { classifyObserveHealth, probeAndClassifyObserve, capabilityForObserveTarget, OBSERVE_START_COMMAND, DEFAULT_OBSERVE_BASE_URL, } from "./observe-health-match.js";
-export { allowedRecoveryCtas, classifyRecoveryFact, recoveryMatrixInvariants, } from "./recovery-cta.js";
+export { allowedRecoveryCtas, classifyRecoveryFact, partitionRecoveryCtas, recoveryMatrixInvariants, } from "./recovery-cta.js";
 export { createClosedResourceLoader, createInterviewResourceLoader, tryActivateTool, assertOfficialToolAllowed, listOfficialTools, OFFICIAL_DENIED_TOOL_IDS, INTERVIEW_ALLOWED_TOOLS, INTERVIEW_DENIED_TOOLS, authorizeInterviewTool, } from "./resource-loader.js";
 export { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 export { openConsoleAppData, defaultConsoleAppDataRoot } from "./app-data.js";

package/dist/worker/console/inspect-split.js

@@ -0,0 +1,82 @@
+function asDisplayText(value) {
+    if (value == null)
+        return null;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed || null;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (typeof value === "object") {
+        const record = value;
+        if (typeof record.text === "string" && record.text.trim()) {
+            return record.text.trim();
+        }
+        if (typeof record.errorMessage === "string" && record.errorMessage.trim()) {
+            return record.errorMessage.trim();
+        }
+        if (Array.isArray(record.content)) {
+            const parts = record.content
+                .map((part) => {
+                if (typeof part === "string")
+                    return part;
+                if (part && typeof part === "object") {
+                    const item = part;
+                    if (typeof item.text === "string")
+                        return item.text;
+                }
+                return "";
+            })
+                .filter(Boolean);
+            if (parts.length)
+                return parts.join("\n").slice(0, 240);
+        }
+        if (typeof record.role === "string") {
+            return `${record.role} 消息`;
+        }
+    }
+    return null;
+}
+export function formatInspectTimelineEvent(event) {
+    const time = asDisplayText(event.at) ??
+        asDisplayText(event.timestamp) ??
+        asDisplayText(event.recordedAt) ??
+        "";
+    const text = asDisplayText(event.errorMessage) ??
+        asDisplayText(event.label) ??
+        asDisplayText(event.type) ??
+        asDisplayText(event.message) ??
+        "运行事件";
+    return time ? `${time} · ${text}` : text;
+}
+export function dagNodeKey(node) {
+    return String(node.nodeId ?? node.id ?? "").trim();
+}
+export function dagNodeLabel(node) {
+    const key = dagNodeKey(node);
+    return String(node.label ?? node.name ?? (key || "未命名节点"));
+}
+export function pickInspectNode(nodes, preferredNodeId) {
+    if (nodes.length === 0)
+        return undefined;
+    const preferred = preferredNodeId?.trim();
+    if (preferred) {
+        const match = nodes.find((node) => dagNodeKey(node) === preferred);
+        if (match)
+            return match;
+    }
+    const failed = nodes.find((node) => {
+        const status = String(node.status ?? "").toLowerCase();
+        return (status.includes("fail") ||
+            status.includes("error") ||
+            status === "blocked");
+    });
+    if (failed)
+        return failed;
+    const running = nodes.find((node) => {
+        const status = String(node.status ?? "").toLowerCase();
+        return status === "running" || status === "in_progress" || status === "active";
+    });
+    return running ?? nodes[0];
+}

package/dist/worker/console/operation-runner.js

@@ -30,7 +30,9 @@ export async function runOperation(operationId, deps) {
     });
     stateEvent(deps.events, op, "starting", "spawning sibling loop-agent");
     const run = deps.runCommand ??
-        ((cliArgs, options) => deps.client.run(cliArgs, options));
+        ((cliArgs, options) => op.externalCommand
+            ? deps.client.runExternal(op.externalCommand, cliArgs, options)
+            : deps.client.run(cliArgs, options));
     let finished;
     try {
         const result = await run(args, {

package/dist/worker/console/operation-store.js

@@ -55,6 +55,7 @@ export class OperationStore {
             createdAt: now,
             taskId: input.taskId,
             cliArgs: input.cliArgs,
+            ...(input.externalCommand ? { externalCommand: input.externalCommand } : {}),
         };
         await writeSecureJson(operationFile(this.appData, operationId), operation);
         await writeSecureJson(indexPath, { operationId, payloadHash });