@xfey/tutti 0.1.78 → 0.1.79

package/dist/chat-assistant/index.d.ts

@@ -32,6 +32,7 @@ export type ReadOnlyChatAssistantEnqueueResult = {
 export type ReadOnlyChatAssistantHandle = {
     enqueue: (input: ReadOnlyChatAssistantTriggerInput) => ReadOnlyChatAssistantEnqueueResult;
     waitForIdle: () => Promise<void>;
+    stopAccepting: () => void;
 };
 export type ReadOnlyChatAssistantOptions = {
     project: {
@@ -44,16 +45,25 @@ export type ReadOnlyChatAssistantOptions = {
     model: ReadOnlyChatAssistantModel;
     promptsRoot?: string;
     onScratchpadSourceChanged?: (message: MessageProjection) => void;
+    waitForInspectionAvailability?: () => Promise<void>;
+    maxQueuedMentions?: number;
     now?: () => Date;
 };
 export declare function isChatAssistantOutput(value: unknown): value is ChatAssistantOutput;
 export declare function containsTuttiMention(value: string): boolean;
 export declare class ReadOnlyChatAssistant implements ReadOnlyChatAssistantHandle {
     private readonly options;
-    private readonly inFlight;
+    private readonly pending;
+    private readonly idleWaiters;
+    private active;
+    private accepting;
+    private readonly maxQueuedMentions;
     constructor(options: ReadOnlyChatAssistantOptions);
     enqueue(input: ReadOnlyChatAssistantTriggerInput): ReadOnlyChatAssistantEnqueueResult;
     waitForIdle(): Promise<void>;
+    stopAccepting(): void;
+    private pump;
+    private resolveIdleIfNeeded;
     private buildMainChatContext;
     private buildClarificationRoundContext;
     private buildContext;

package/dist/chat-assistant/index.js

@@ -97,23 +97,76 @@ function roundMessagesToContext(messages) {
 }
 export class ReadOnlyChatAssistant {
     options;
-    inFlight = new Set();
+    pending = [];
+    idleWaiters = new Set();
+    active = null;
+    accepting = true;
+    maxQueuedMentions;
     constructor(options) {
         this.options = options;
+        this.maxQueuedMentions = options.maxQueuedMentions ?? 8;
     }
     enqueue(input) {
         if (!containsTuttiMention(input.message.body)) {
             return { triggered: false };
         }
-        const task = this.respond(input.message).catch(() => undefined);
-        this.inFlight.add(task);
-        void task.finally(() => {
-            this.inFlight.delete(task);
-        });
+        if (!this.accepting) {
+            return { triggered: false };
+        }
+        if (this.pending.length >= this.maxQueuedMentions) {
+            this.appendAssistantMessageForTrigger(input.message, assistantFailureMessage(), {
+                scratchpad_source: "exclude",
+            });
+            return { triggered: true };
+        }
+        this.pending.push(input.message);
+        this.pump();
         return { triggered: true };
     }
     async waitForIdle() {
-        await Promise.all([...this.inFlight]);
+        if (this.active === null && this.pending.length === 0) {
+            return;
+        }
+        await new Promise((resolve) => this.idleWaiters.add(resolve));
+    }
+    stopAccepting() {
+        if (!this.accepting) {
+            return;
+        }
+        this.accepting = false;
+        for (const message of this.pending.splice(0)) {
+            this.appendAssistantMessageForTrigger(message, assistantFailureMessage(), {
+                scratchpad_source: "exclude",
+            });
+        }
+        this.resolveIdleIfNeeded();
+    }
+    pump() {
+        if (this.active !== null) {
+            return;
+        }
+        const message = this.pending.shift();
+        if (message === undefined) {
+            this.resolveIdleIfNeeded();
+            return;
+        }
+        const task = this.respond(message).catch(() => undefined);
+        this.active = task;
+        void task.finally(() => {
+            if (this.active === task) {
+                this.active = null;
+                this.pump();
+            }
+        });
+    }
+    resolveIdleIfNeeded() {
+        if (this.active !== null || this.pending.length !== 0) {
+            return;
+        }
+        for (const resolve of this.idleWaiters) {
+            resolve();
+        }
+        this.idleWaiters.clear();
     }
     buildMainChatContext(triggerMessage) {
         const authorDisplayName = triggerMessage.author.display_name?.trim();
@@ -249,6 +302,7 @@ export class ReadOnlyChatAssistant {
     }
     async respond(triggerMessage) {
         try {
+            await this.options.waitForInspectionAvailability?.();
             const prompt = this.renderPrompt(triggerMessage);
             if (prompt === null) {
                 return;

package/dist/checks/index.d.ts

@@ -1,4 +1,5 @@
 import type { CheckSkipReasonCode } from "@tutti/shared/schemas/api";
+import { type ProcessTreeTerminationOptions } from "../process-tree.js";
 export type CheckCommand = {
     id: string;
     label: string;
@@ -41,7 +42,28 @@ export type ExecuteCheckPlanOptions = {
     workspaceRoot: string;
     plan: CheckPlan;
     timeoutMs?: number;
+    termination?: ProcessTreeTerminationOptions;
+    processCoordinator?: CheckProcessCoordinator;
 };
+type ActiveCheckProcess = {
+    markAborted: () => void;
+    terminate: (options?: ProcessTreeTerminationOptions) => Promise<unknown>;
+};
+export declare class CheckExecutionAbortedError extends Error {
+    constructor();
+}
+export declare class CheckProcessCoordinator {
+    private accepting;
+    private readonly active;
+    private readonly idleWaiters;
+    get activeCount(): number;
+    register(active: ActiveCheckProcess): (() => void) | null;
+    stopAccepting(): void;
+    terminateActive(options?: ProcessTreeTerminationOptions): Promise<void>;
+    waitForIdle(): Promise<void>;
+    private resolveIdleIfNeeded;
+}
 export declare function createNodeNpmCheckPlan(options: CreateNodeNpmCheckPlanOptions): CheckPlan;
 export declare function executeCheckPlan(options: ExecuteCheckPlanOptions): Promise<ChecksExecutionResult>;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/checks/index.js

@@ -2,6 +2,62 @@ import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { redactText } from "@tutti/shared/utils/redaction";
+import { createManagedChildProcess, terminateManagedProcessTree, } from "../process-tree.js";
+export class CheckExecutionAbortedError extends Error {
+    constructor() {
+        super("Project checks were stopped because the Host is shutting down.");
+        this.name = "CheckExecutionAbortedError";
+    }
+}
+export class CheckProcessCoordinator {
+    accepting = true;
+    active = new Set();
+    idleWaiters = new Set();
+    get activeCount() {
+        return this.active.size;
+    }
+    register(active) {
+        if (!this.accepting) {
+            active.markAborted();
+            return null;
+        }
+        this.active.add(active);
+        let released = false;
+        return () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            this.active.delete(active);
+            this.resolveIdleIfNeeded();
+        };
+    }
+    stopAccepting() {
+        this.accepting = false;
+    }
+    async terminateActive(options = {}) {
+        const active = [...this.active];
+        for (const entry of active) {
+            entry.markAborted();
+        }
+        await Promise.all(active.map((entry) => entry.terminate(options)));
+    }
+    waitForIdle() {
+        if (this.active.size === 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => this.idleWaiters.add(resolve));
+    }
+    resolveIdleIfNeeded() {
+        if (this.active.size !== 0) {
+            return;
+        }
+        for (const resolve of this.idleWaiters) {
+            resolve();
+        }
+        this.idleWaiters.clear();
+    }
+}
 const DEFAULT_CHECK_TIMEOUT_MS = 120_000;
 const MAX_OUTPUT_BYTES = 16 * 1024;
 const DEFAULT_SKIP_REASON = "no_validation_command_found";
@@ -83,25 +139,71 @@ function commandEnvironment() {
 }
 function runCheckCommand(options) {
     const startedAt = Date.now();
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
         const child = spawn(options.command.command, options.command.args, {
             cwd: options.workspaceRoot,
+            detached: process.platform !== "win32",
             env: commandEnvironment(),
             shell: false,
             stdio: ["ignore", "pipe", "pipe"],
         });
+        const managedProcess = createManagedChildProcess(child);
         const stdout = [];
         const stderr = [];
         let timedOut = false;
+        let aborted = false;
+        let settled = false;
+        let terminationPromise;
+        const terminate = (termination) => {
+            terminationPromise ??= terminateManagedProcessTree(managedProcess, termination ?? options.termination);
+            return terminationPromise;
+        };
+        const release = options.processCoordinator?.register({
+            markAborted: () => {
+                aborted = true;
+            },
+            terminate,
+        });
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            release?.();
+            if (aborted) {
+                reject(new CheckExecutionAbortedError());
+                return;
+            }
+            resolve(result);
+        };
+        const failTermination = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            reject(error instanceof Error
+                ? error
+                : new Error("Check process termination failed without a structured error."));
+        };
+        const finishAfterTermination = (result) => {
+            if (terminationPromise === undefined) {
+                finish(result);
+                return;
+            }
+            void terminationPromise.then(() => finish(result), (error) => failTermination(error));
+        };
         const timeout = setTimeout(() => {
             timedOut = true;
-            child.kill("SIGTERM");
+            void terminate().catch(failTermination);
         }, options.timeoutMs);
+        if (release === null) {
+            void terminate().catch(failTermination);
+        }
         child.stdout.on("data", (chunk) => stdout.push(chunk));
         child.stderr.on("data", (chunk) => stderr.push(chunk));
         child.on("error", (error) => {
             clearTimeout(timeout);
-            resolve({
+            finishAfterTermination({
                 id: options.command.id,
                 label: options.command.label,
                 command: options.command.command,
@@ -114,7 +216,7 @@ function runCheckCommand(options) {
         });
         child.on("close", (code) => {
             clearTimeout(timeout);
-            resolve({
+            finishAfterTermination({
                 id: options.command.id,
                 label: options.command.label,
                 command: options.command.command,
@@ -143,6 +245,10 @@ export async function executeCheckPlan(options) {
             workspaceRoot: options.workspaceRoot,
             command,
             timeoutMs: options.timeoutMs ?? DEFAULT_CHECK_TIMEOUT_MS,
+            ...(options.termination === undefined ? {} : { termination: options.termination }),
+            ...(options.processCoordinator === undefined
+                ? {}
+                : { processCoordinator: options.processCoordinator }),
         }));
     }
     const requiredCommands = options.plan.commands.filter((command) => command.required);

package/dist/control-plane/follow-up-start.d.ts

@@ -22,5 +22,6 @@ export declare function startControlPlaneTaskBoundFollowUpCheck(options: {
     now: () => Date;
     publishProcedureTransition: (state: ProcedureEngineState) => void;
     startRunForTask: (runInput: StartRunForTaskInput) => void;
+    shouldContinue?: () => boolean;
 }): boolean;
 //# sourceMappingURL=follow-up-start.d.ts.map

package/dist/control-plane/follow-up-start.js

@@ -19,7 +19,9 @@ export function startControlPlaneTaskBoundFollowUpCheck(options) {
         now: options.now,
         onTransition: (state) => {
             options.publishProcedureTransition(state);
-            if (state.activity.status === "finished" && output?.decision === "resume") {
+            if (state.activity.status === "finished" &&
+                output?.decision === "resume" &&
+                options.shouldContinue?.() !== false) {
                 startRunFromFollowUpSuccessor({
                     store: options.store,
                     events: options.events,

package/dist/control-plane/index.d.ts

@@ -22,6 +22,8 @@ export declare class Phase5ControlPlane {
     private readonly referenceSummaryWaiters;
     private pendingAllReferenceSummaries;
     private referenceSummaryStartScheduled;
+    private closing;
+    private readonly asyncOwners;
     private lastRecoveryConclusion;
     constructor(options: Phase5ControlPlaneOptions);
     getExecutionStatus(): ExecutionStatusProjection;
@@ -36,7 +38,9 @@ export declare class Phase5ControlPlane {
         workflowRef?: WorkflowInvocationRef;
         activityRef?: ActivityRef;
     }): Promise<RefreshProjectBriefProjectionResult>;
-    dispose(): void;
+    beginShutdown(): void;
+    dispose(): Promise<void>;
+    waitForRepoInspectionIdle(): Promise<void>;
     startTaskCompile(payload: SubmitWorklistPayload): ControlPlaneCommandResult<SubmitWorklistDisposition, SubmitWorklistResult>;
     startContextSyncAnalysis(trigger?: ContextSyncWorkflowTrigger): ControlPlaneCommandResult<ContextSyncDisposition, ContextSyncResult>;
     startReferenceSummaryRefresh(payload?: RefreshReferenceSummariesPayload): ControlPlaneCommandResult<RefreshReferenceSummariesDisposition, RefreshReferenceSummariesResult>;
@@ -44,6 +48,7 @@ export declare class Phase5ControlPlane {
     sendClarificationRoundMessage(roundId: ClarificationRoundRef, payload: SendClarificationRoundMessagePayload, author: TrustedHumanAuthor): ControlPlaneCommandResult<SendClarificationRoundMessageDisposition, SendClarificationRoundMessageResult>;
     submitClarificationRound(roundId: ClarificationRoundRef, payload: SubmitClarificationRoundPayload, commandId: IdempotencyKey): ControlPlaneCommandResult<SubmitClarificationRoundDisposition, SubmitClarificationRoundResult>;
     waitForIdle(): Promise<void>;
+    private trackAsyncOwner;
     private hasPendingReferenceSummaryRefresh;
     private schedulePendingReferenceSummaryRefresh;
     private startRunForTask;

package/dist/control-plane/index.js

@@ -36,6 +36,8 @@ export class Phase5ControlPlane {
     referenceSummaryWaiters = new Map();
     pendingAllReferenceSummaries = false;
     referenceSummaryStartScheduled = false;
+    closing = false;
+    asyncOwners = new Set();
     lastRecoveryConclusion = null;
     constructor(options) {
         this.store = options.store;
@@ -115,7 +117,7 @@ export class Phase5ControlPlane {
         this.scratchpadAutoRefreshScheduler.notifySourceChanged();
     }
     refreshProjectBrief(options) {
-        return refreshProjectBriefProjection({
+        return this.trackAsyncOwner(refreshProjectBriefProjection({
             store: this.store,
             projectContext: this.projectContext,
             reason: options.reason,
@@ -124,12 +126,46 @@ export class Phase5ControlPlane {
             ...(options.activityRef === undefined ? {} : { activityRef: options.activityRef }),
             logger: this.logger,
             now: this.now,
-        });
+        }));
     }
-    dispose() {
+    beginShutdown() {
+        if (this.closing) {
+            return;
+        }
+        this.closing = true;
         this.scratchpadAutoRefreshScheduler.dispose();
+        this.pendingAllReferenceSummaries = false;
+        this.pendingReferenceSummaryPaths.clear();
+    }
+    dispose() {
+        this.beginShutdown();
+        return this.waitForIdle();
+    }
+    async waitForRepoInspectionIdle() {
+        for (;;) {
+            const waits = [];
+            if (this.readActiveRun() !== null) {
+                waits.push(this.runEngine.waitForIdle());
+            }
+            if (this.readActiveForegroundProcedure() !== null) {
+                waits.push(this.engine.waitForLaneIdle("foreground"));
+            }
+            if (waits.length === 0) {
+                return;
+            }
+            await Promise.all(waits);
+        }
     }
     startTaskCompile(payload) {
+        const activeRun = this.readActiveRun();
+        if (activeRun !== null) {
+            return {
+                disposition: {
+                    kind: "already_running",
+                    activity_ref: activeRun.activity_ref,
+                },
+            };
+        }
         let tasksAdded = false;
         return startControlPlaneTaskCompile({
             engine: this.engine,
@@ -142,7 +178,8 @@ export class Phase5ControlPlane {
             now: this.now,
             publishProcedureTransition: (state) => {
                 this.publishProcedureTransition(state);
-                if (tasksAdded &&
+                if (!this.closing &&
+                    tasksAdded &&
                     state.activity.status === "finished" &&
                     state.activity.workflow_kind === "task_compile") {
                     this.tryRunTaskArrivalScheduler();
@@ -156,6 +193,7 @@ export class Phase5ControlPlane {
             onTasksAdded: () => {
                 tasksAdded = true;
             },
+            shouldContinue: () => !this.closing,
         });
     }
     startContextSyncAnalysis(trigger = { kind: "manual" }) {
@@ -261,25 +299,36 @@ export class Phase5ControlPlane {
         while (true) {
             await this.engine.waitForIdle();
             await this.runEngine.waitForIdle();
+            await Promise.allSettled([...this.asyncOwners]);
             await Promise.resolve();
             if (this.readAnyActiveActivity() === null &&
-                !this.hasPendingReferenceSummaryRefresh()) {
+                this.asyncOwners.size === 0 &&
+                (this.closing || !this.hasPendingReferenceSummaryRefresh())) {
                 return;
             }
-            this.schedulePendingReferenceSummaryRefresh();
+            if (!this.closing) {
+                this.schedulePendingReferenceSummaryRefresh();
+            }
         }
     }
+    trackAsyncOwner(owner) {
+        this.asyncOwners.add(owner);
+        void owner.then(() => this.asyncOwners.delete(owner), () => this.asyncOwners.delete(owner));
+        return owner;
+    }
     hasPendingReferenceSummaryRefresh() {
         return this.pendingAllReferenceSummaries || this.pendingReferenceSummaryPaths.size !== 0;
     }
     schedulePendingReferenceSummaryRefresh() {
-        if (!this.hasPendingReferenceSummaryRefresh() || this.referenceSummaryStartScheduled) {
+        if (this.closing ||
+            !this.hasPendingReferenceSummaryRefresh() ||
+            this.referenceSummaryStartScheduled) {
             return;
         }
         this.referenceSummaryStartScheduled = true;
         queueMicrotask(() => {
             this.referenceSummaryStartScheduled = false;
-            if (this.hasPendingReferenceSummaryRefresh()) {
+            if (!this.closing && this.hasPendingReferenceSummaryRefresh()) {
                 void this.tryStartPendingReferenceSummaryRefresh();
             }
         });
@@ -417,6 +466,9 @@ export class Phase5ControlPlane {
         }
     }
     tryRunTaskArrivalScheduler() {
+        if (this.closing) {
+            return false;
+        }
         const result = runControlPlaneSchedulerForTaskArrival({
             store: this.store,
             resolveRunPipeline: this.resolveRunPipeline,
@@ -446,6 +498,9 @@ export class Phase5ControlPlane {
         };
     }
     maybeStartContextSyncAfterWorklistCompletion() {
+        if (this.closing) {
+            return;
+        }
         const trigger = this.worklistCompletionContextSyncTrigger();
         if (trigger === undefined || this.readSchedulerBlocker() !== null) {
             return;
@@ -466,7 +521,8 @@ export class Phase5ControlPlane {
             now: this.now,
             publishProcedureTransition: (state) => {
                 this.publishProcedureTransition(state);
-                if (tasksAdded &&
+                if (!this.closing &&
+                    tasksAdded &&
                     state.activity.status === "finished" &&
                     state.activity.workflow_kind === "task_compile") {
                     this.tryRunTaskArrivalScheduler();
@@ -492,8 +548,11 @@ export class Phase5ControlPlane {
             now: this.now,
             publishProcedureTransition: (state) => this.publishProcedureTransition(state),
             startRunForTask: (runInput) => {
-                void this.startRunForTask(runInput);
+                if (!this.closing) {
+                    void this.startRunForTask(runInput);
+                }
             },
+            shouldContinue: () => !this.closing,
         });
     }
     publishProcedureTransition(state) {
@@ -521,7 +580,9 @@ export class Phase5ControlPlane {
                     }, "Reference summary continuation failed");
                 }
             }
-            this.schedulePendingReferenceSummaryRefresh();
+            if (!this.closing) {
+                this.schedulePendingReferenceSummaryRefresh();
+            }
         }
     }
     logProcedureTransition(state) {

package/dist/control-plane/procedure-logging.js

@@ -1,77 +1,35 @@
-const MAX_ERROR_MESSAGE_LENGTH = 1_000;
-const MAX_DETAIL_STRING_LENGTH = 1_000;
 const MAX_DETAIL_ARRAY_ITEMS = 20;
-const MAX_DETAIL_OBJECT_KEYS = 40;
+const SAFE_DETAIL_KEYS = [
+    "turn_status",
+    "turn_error_code",
+    "turn_error_http_status",
+    "turn_timeout_ms",
+    "last_activity_at",
+    "notification_count",
+    "server_request_methods",
+    "notification_methods",
+];
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function compactString(value, maxLength) {
-    const normalized = value.replace(/\s+/gu, " ").trim();
-    if (normalized.length <= maxLength) {
-        return normalized;
-    }
-    return `${normalized.slice(0, maxLength)}...`;
-}
-function boundedDetailValue(value, seen = new WeakSet()) {
-    if (value === null ||
-        typeof value === "number" ||
-        typeof value === "boolean" ||
-        typeof value === "undefined") {
-        return value;
-    }
-    if (typeof value === "string") {
-        return compactString(value, MAX_DETAIL_STRING_LENGTH);
-    }
-    if (typeof value === "bigint") {
-        return value.toString();
-    }
-    if (Array.isArray(value)) {
-        const items = value
-            .slice(0, MAX_DETAIL_ARRAY_ITEMS)
-            .map((item) => boundedDetailValue(item, seen));
-        if (value.length > MAX_DETAIL_ARRAY_ITEMS) {
-            items.push(`[${value.length - MAX_DETAIL_ARRAY_ITEMS} more items]`);
-        }
-        return items;
-    }
-    if (value instanceof Error) {
-        return {
-            name: value.name,
-            message: compactString(value.message, MAX_DETAIL_STRING_LENGTH),
-        };
+function errorDetails(error) {
+    if (!isRecord(error) || !isRecord(error.details)) {
+        return undefined;
     }
-    if (isRecord(value)) {
-        if (seen.has(value)) {
-            return "[Circular]";
-        }
-        seen.add(value);
-        const entries = Object.entries(value);
-        const bounded = {};
-        for (const [key, nested] of entries.slice(0, MAX_DETAIL_OBJECT_KEYS)) {
-            const boundedNested = boundedDetailValue(nested, seen);
-            if (boundedNested !== undefined) {
-                bounded[key] = boundedNested;
-            }
+    const safe = {};
+    for (const key of SAFE_DETAIL_KEYS) {
+        const value = error.details[key];
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            safe[key] = value;
+            continue;
         }
-        if (entries.length > MAX_DETAIL_OBJECT_KEYS) {
-            bounded.truncated_key_count = entries.length - MAX_DETAIL_OBJECT_KEYS;
+        if (Array.isArray(value)) {
+            safe[key] = value
+                .filter((item) => typeof item === "string")
+                .slice(0, MAX_DETAIL_ARRAY_ITEMS);
         }
-        seen.delete(value);
-        return bounded;
-    }
-    if (typeof value === "function") {
-        return value.name.trim().length === 0 ? "[Function]" : `[Function:${value.name}]`;
-    }
-    if (typeof value === "symbol") {
-        return value.description === undefined ? "[Symbol]" : `[Symbol:${value.description}]`;
-    }
-    return "[Unsupported]";
-}
-function errorDetails(error) {
-    if (!isRecord(error) || !("details" in error)) {
-        return undefined;
     }
-    return boundedDetailValue(error.details);
+    return Object.keys(safe).length === 0 ? undefined : safe;
 }
 function errorCode(error) {
     if (!isRecord(error) || typeof error.code !== "string") {
@@ -85,7 +43,6 @@ export function logProcedureExecutionError(input) {
         workflow_ref: input.workflowRef,
         workflow_kind: input.workflowKind,
         error_name: input.error instanceof Error ? input.error.name : "NonError",
-        error_message: compactString(input.error instanceof Error ? input.error.message : String(input.error), MAX_ERROR_MESSAGE_LENGTH),
         ...(errorCode(input.error) === undefined ? {} : { error_code: errorCode(input.error) }),
         ...(errorDetails(input.error) === undefined
             ? {}

package/dist/control-plane/project-context-bootstrap.js

@@ -73,7 +73,13 @@ export async function tryProjectContextBootstrapDocuments(input) {
         input.logger?.info({
             workflow_ref: input.workflowRef,
             activity_ref: input.activityRef,
-            error: error instanceof Error ? error.message : "unknown error",
+            error_name: error instanceof Error ? error.name : "NonError",
+            ...(typeof error === "object" &&
+                error !== null &&
+                "code" in error &&
+                typeof error.code === "string"
+                ? { error_code: error.code }
+                : {}),
         }, "Project context bootstrap model plan unavailable; falling back to local templates");
         return undefined;
     }

package/dist/control-plane/reference-summary-refresh.js

@@ -2,7 +2,7 @@ import { createWorkflowInvocationRef } from "@tutti/shared/ids";
 import { recordProjectTimelineEvent } from "../project-timeline/index.js";
 import { WorkspaceOpsError, readReferenceSummaryTargets, updateReferenceSummaries, } from "../workspace-ops/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
-const REFERENCE_SUMMARY_CONCURRENCY = 2;
+const REFERENCE_SUMMARY_CONCURRENCY = 1;
 const REFERENCE_SUMMARY_MAX_ATTEMPTS = 2;
 function publishReferenceSummaryTimelineChanged(input) {
     input.events.publish({