@galaxy-stack/ai-coder-core 0.3.0-alpha.9 → 0.3.1

package/dist/runtime/run-controller.js

@@ -1,5 +1,6 @@
 import { AiCoderContextBudgetError, AiCoderContextManager, } from "../context/context-manager.js";
 import { compareAiCoderText } from "../deterministic-order.js";
+import { isGeneratedWorkspacePath } from "./workspace-generated-path.js";
 import { assertAiCoderRunCheckpoint, createAiCoderRunCheckpoint, hashAiCoderCanonicalValue, isAiCoderWorkspaceMutationEvidence, canonicalJson, redactAiCoderCheckpointText, } from "../context/checkpoint.js";
 import { boundAiCoderToolOutput } from "../context/tool-output.js";
 import { assembleAiCoderPrompt, createAiCoderTaskContract, formatAiCoderUserTask, } from "../prompt/prompt-assembler.js";
@@ -18,13 +19,23 @@ const DEFAULT_BUDGET = Object.freeze({
     maxModelRetries: 3,
     modelRetryDelaysMs: Object.freeze([1_000, 3_000, 8_000]),
     maxRepeatedToolRequests: 2,
-    maxToolCalls: 128,
+    maxToolCalls: 256,
     maxTurns: 48,
     noProgressPolicy: "advisory",
     observationNudgeThresholds: Object.freeze([3, 5, 8]),
     persistenceGraceMs: 10_000,
     toolOutput: Object.freeze({ maxBytes: 48_000, maxTokens: 12_000, tailFraction: 0.25 }),
 });
+/** Common model aliases for Galaxy tool names, mapped only when the target is active. */
+const TOOL_NAME_ALIASES = Object.freeze({
+    bash: "run_command", shell: "run_command", exec: "run_command", execute: "run_command", terminal: "run_command",
+    read: "read_file", cat: "read_file", view_file: "read_file",
+    write: "write_file", create_file: "write_file",
+    edit: "edit_file", str_replace: "edit_file", replace: "edit_file", apply_patch: "edit_file",
+    glob: "glob_files", find_files: "glob_files",
+    grep: "search_text", search: "search_text",
+    ls: "list_files", list: "list_files",
+});
 const STABLE_OBSERVATION_TOOL_IDS = new Set([
     "artifact.list",
     "artifact.read",
@@ -660,7 +671,8 @@ function mandatoryState(session) {
         acceptanceCriteria: session.evidence.acceptanceCriteria,
         approvals: session.evidence.approvals,
         decisions: session.evidence.decisions,
-        editedFiles: session.evidence.writes,
+        editedFiles: session.evidence.writes.slice(-200),
+        editedFilesTotal: session.evidence.writes.length,
         executionBudget: {
             remainingModelTurns: Math.max(0, session.budget.maxTurns - session.modelTurns),
             remainingToolCalls: Math.max(0, session.budget.maxToolCalls - session.toolCalls),
@@ -787,7 +799,9 @@ export class AiCoderRunController {
             evidence: createEvidence(requestSnapshot),
             executionId,
             failedToolFamilies: new Map(),
+            finalizationAttempted: false,
             finalizationMode: false,
+            generatedChurnEvents: 0,
             hostStateVersions: new Map(),
             integrity: null,
             latestCheckpoint: null,
@@ -1019,7 +1033,7 @@ export class AiCoderRunController {
             ...session.integrity,
             systemPromptHash,
         });
-        session.contextManager?.replaceSystemPrompt(promptSnapshot.systemPrompt, session.modelTurns);
+        session.contextManager?.replaceSystemPrompt(promptSnapshot.systemPrompt, session.modelTurns, session.capabilities?.systemPromptUpdate === "in-history" ? "in-history" : "in-place");
         return true;
     }
     async prepare(session) {
@@ -1113,7 +1127,20 @@ export class AiCoderRunController {
                 await this.notify(session, { pressure: diagnostic.pressure, tokens: diagnostic.currentInputTokens, type: "context_pressure" });
             },
             goalMessage: userTaskMessage,
-            ledgerSink: async (entry) => session.trace.emit("token_ledger", entry),
+            ledgerSink: async (entry) => {
+                await session.trace.emit("token_ledger", entry);
+                await this.notify(session, {
+                    ledger: Object.freeze({
+                        actualInput: entry.actualInput,
+                        cacheHitRate: entry.cacheHitRate,
+                        cachedInput: entry.cachedInput,
+                        cumulativeCacheHitRate: entry.cumulativeCacheHitRate,
+                        outputTokens: entry.outputTokens,
+                        turn: entry.turn,
+                    }),
+                    type: "token_ledger",
+                });
+            },
             profile: session.request.tokenProfile ?? "balanced",
             ...(checkpoint ? { resumeCheckpoint: checkpoint } : {}),
             runId: session.context.runId,
@@ -1318,6 +1345,9 @@ export class AiCoderRunController {
                 await this.emitPromptSnapshot(session);
             const contextManager = session.contextManager;
             const roundToolSet = session.toolSet;
+            // The finalization turn must be tool-free (host conformance). The prompt
+            // cache still benefits from the stable message prefix and appended
+            // feedback; only the tool list is dropped.
             const roundDefinitions = session.finalizationMode
                 ? Object.freeze([])
                 : roundToolSet.definitions;
@@ -1393,7 +1423,7 @@ export class AiCoderRunController {
                 const observations = [];
                 for (let index = 0; index < preparedCalls.length; index += 1) {
                     const preparedCall = preparedCalls[index];
-                    observations.push(await this.executeToolCall(session, preparedCall, roundToolSet));
+                    observations.push(await this.executeToolCallGuarded(session, preparedCall, roundToolSet));
                     if (session.evidence.pendingApprovals.size && index + 1 < preparedCalls.length) {
                         for (const skipped of preparedCalls.slice(index + 1)) {
                             observations.push(await this.recordApprovalBlockedToolCall(session, skipped, roundToolSet));
@@ -1438,6 +1468,18 @@ export class AiCoderRunController {
                 return result;
             session.finalizationMode = false;
         }
+        // Out of turns is not out of options. A heavy step can reach the turn cap with
+        // its evidence already satisfied (observed: a gymflow step failed right after
+        // "Project validation passed"). Grant exactly one tool-free finalization turn
+        // so the run reports the evidence it has; the completion gate still decides
+        // whether that report is acceptable, and a second exhaustion still fails.
+        if (!session.finalizationAttempted && this.shouldAttemptFinalization(session)) {
+            session.finalizationAttempted = true;
+            this.enterFinalizationMode(session);
+            session.budget = Object.freeze({ ...session.budget, maxTurns: session.modelTurns + 1 });
+            await this.tracePolicyDecision(session, Object.freeze({ action: "budget_finalization_turn", maxTurns: session.budget.maxTurns }));
+            return this.runLoop(session);
+        }
         throw new AiCoderRuntimeError("MAX_TURNS", `AI Coder reached maxTurns=${session.budget.maxTurns}.`);
     }
     async runModelRound(session, messages, includeAttachments, maxOutputTokens, tools) {
@@ -1514,7 +1556,14 @@ export class AiCoderRunController {
                 }
                 if (!done)
                     throw new CodingProviderError("MALFORMED_STREAM", "Model stream ended without a done event.");
-                if (done.stopReason === "length" || done.stopReason === "unknown") {
+                if (done.stopReason === "length") {
+                    // The model spent its whole output allowance (usually on hidden thinking)
+                    // before emitting a tool call or an answer. That is a capacity failure, not
+                    // a task failure: retry the same verified context with thinking disabled
+                    // instead of failing the run (measured: a gymflow planning turn died here).
+                    throw new CodingProviderError("MALFORMED_STREAM", `Model stopped at the output limit ('length') after ${calls.length} tool call(s) and ${content.length} character(s) of content; retry with hidden thinking disabled and a shorter response.`, true, "without_thinking");
+                }
+                if (done.stopReason === "unknown") {
                     throw new AiCoderRuntimeError("INVALID_MODEL_STREAM", `Model stopped with non-final reason '${done.stopReason}'.`);
                 }
                 if (done.stopReason === "tool_calls" && !calls.length) {
@@ -1689,6 +1738,35 @@ export class AiCoderRunController {
         if (new Set(callIds).size !== callIds.length || callIds.some((id) => !id.trim())) {
             throw new AiCoderRuntimeError("INVALID_MODEL_STREAM", "Model returned duplicate or empty toolCallId values.");
         }
+        // Models trained on other agent frameworks occasionally emit well-known
+        // aliases (for example "bash" for run_command). Map an alias onto the
+        // canonical model name when it is active this round.
+        const visibleNames = new Set(roundToolSet.definitions.map((definition) => definition.function.name));
+        const normalizedCalls = calls.map((call) => {
+            let normalized = call;
+            if (!visibleNames.has(normalized.name)) {
+                const alias = TOOL_NAME_ALIASES[normalized.name];
+                if (alias !== undefined && visibleNames.has(alias))
+                    normalized = Object.freeze({ ...normalized, name: alias });
+            }
+            if (normalized.name === "edit_file") {
+                // The edit precondition is optional and advisory at the agent layer:
+                // a hash remembered from an earlier turn or compacted context is stale
+                // and would otherwise loop on PRECONDITION_FAILED. Drop it and let the
+                // oldText match be the guard. The port still enforces a precondition
+                // when a host supplies one directly.
+                const args = normalized.arguments;
+                if (args !== null && typeof args === "object" && !Array.isArray(args) && "precondition" in args) {
+                    const { precondition: _drop, ...rest } = args;
+                    normalized = Object.freeze({ ...normalized, arguments: Object.freeze(rest) });
+                }
+            }
+            return normalized;
+        });
+        const unavailableName = normalizedCalls.find((call) => !visibleNames.has(call.name))?.name;
+        if (unavailableName !== undefined) {
+            throw new AiCoderRuntimeError("INVALID_MODEL_STREAM", `Tool ${unavailableName} was not active in the registry snapshot shown to the model for this round.`);
+        }
         const reusedId = callIds.find((id) => session.evidence.seenToolCallIds.has(id));
         if (reusedId !== undefined) {
             throw new AiCoderRuntimeError("INVALID_MODEL_STREAM", `toolCallId ${reusedId} was already used in this run.`);
@@ -1696,11 +1774,6 @@ export class AiCoderRunController {
         if (session.toolCalls + calls.length > session.budget.maxToolCalls) {
             throw new AiCoderRuntimeError("MAX_TOOL_CALLS", `AI Coder reached maxToolCalls=${session.budget.maxToolCalls}.`);
         }
-        const visibleNames = new Set(roundToolSet.definitions.map((definition) => definition.function.name));
-        const unavailableName = calls.find((call) => !visibleNames.has(call.name))?.name;
-        if (unavailableName !== undefined) {
-            throw new AiCoderRuntimeError("INVALID_MODEL_STREAM", `Tool ${unavailableName} was not active in the registry snapshot shown to the model for this round.`);
-        }
         const prepared = [];
         for (const call of calls) {
             try {
@@ -1712,6 +1785,28 @@ export class AiCoderRunController {
         }
         return Object.freeze(prepared);
     }
+    /**
+     * Bound a single tool dispatch. A native or host tool that blocks forever
+     * would otherwise hang the whole run; a timeout fails the run cleanly with a
+     * diagnosable code instead.
+     */
+    async executeToolCallGuarded(session, prepared, roundToolSet) {
+        const timeoutMs = 600_000;
+        let timer;
+        try {
+            return await Promise.race([
+                this.executeToolCall(session, prepared, roundToolSet),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new AiCoderRuntimeError("TOOL_TIMEOUT", `Tool ${prepared.call.name} did not return within ${timeoutMs}ms.`)), timeoutMs);
+                    timer.unref?.();
+                }),
+            ]);
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        }
+    }
     async executeToolCall(session, prepared, roundToolSet) {
         if (!session.contextManager || !session.toolSet)
             throw new Error("Context manager or tool set is unavailable.");
@@ -1740,7 +1835,9 @@ export class AiCoderRunController {
         const callRecord = {
             // Bounded, redacted digest so the post-compaction checkpoint shows WHICH
             // paths/queries were already inspected; hashes alone cannot stop re-listing.
-            argumentDigest: redactAiCoderCheckpointText(canonicalJson(call.arguments)).slice(0, 160),
+            argumentDigest: redactAiCoderCheckpointText(canonicalJson(call.arguments))
+                .replace(/"contentSha256":"[a-f0-9]{64}"/gu, '"contentSha256":"<re-read to refresh>"')
+                .slice(0, 160),
             argumentsHash,
             idempotencyKey,
             name: call.name,
@@ -1959,9 +2056,19 @@ export class AiCoderRunController {
             research: session.evidence.researchSources,
             writes: session.evidence.writes,
         });
+        const authoredWrites = (normalizedResult.effects?.writes ?? []).filter((write) => !isGeneratedWorkspacePath(write.path.split("/")));
+        const durableAuthoredProgress = Boolean(effectCanChangeState && normalizedResult.effects && (authoredWrites.length > 0
+            || normalizedResult.effects.diffReview
+            || normalizedResult.effects.plan
+            || (normalizedResult.effects.researchSources?.length ?? 0) > 0
+            || (normalizedResult.effects.acceptanceCriteriaSatisfied?.length ?? 0) > 0
+            || (normalizedResult.effects.acceptanceCriteriaWaived?.length ?? 0) > 0
+            || (normalizedResult.effects.inspectedPaths?.length ?? 0) > 0));
         if (hasStateEffect && nextStateVersion !== previousStateVersion) {
             session.stateVersion = nextStateVersion;
-            if ((normalizedResult.ok || normalizedResult.effects?.approval === "denied") && !noProgressDetected) {
+            // A generated-only state change (build output, caches, tsbuildinfo) is not
+            // authored progress, so it must not clear the no-progress budget.
+            if (durableAuthoredProgress && (normalizedResult.ok || normalizedResult.effects?.approval === "denied") && !noProgressDetected) {
                 session.repeatedToolFingerprint = 0;
                 session.noProgressEpisodes = 0;
                 session.lastNoProgressEpisodeTurn = -1;
@@ -2345,6 +2452,10 @@ export class AiCoderRunController {
         }
         const cyclingPaths = [];
         for (const write of effects.writes ?? []) {
+            // Build output/caches are durable host effects (run_command proof) but are
+            // not authored source; keep them out of the authored write evidence.
+            if (isGeneratedWorkspacePath(write.path.split("/")))
+                continue;
             const beforeState = workspaceStateKey(write.beforeKind, write.beforeHash);
             const afterState = workspaceStateKey(write.afterKind, write.afterHash);
             let history = session.writeStateHistory.get(write.path) ?? [];
@@ -2597,7 +2708,27 @@ export class AiCoderRunController {
             const messages = gate.issues.map((item) => `${item.code}: ${item.detail}`);
             const researchEvidence = completionRejectionResearchEvidence(session, content);
             const remediation = gate.issues.flatMap((item) => {
+                if (item.code === "WORKSPACE_EVIDENCE_STALE") {
+                    return [
+                        "WORKSPACE_EVIDENCE_STALE next action: workspace changed after those validations ran, so their evidence is void. Re-run validate_project with the SAME checks for each stale id AFTER the latest mutation; a validation older than the last write never counts. Do not re-run validations that are already current.",
+                    ];
+                }
+                if (item.code === "WRITE_NOT_VALIDATED") {
+                    return [
+                        "WRITE_NOT_VALIDATED next action: run validate_project (checks covering the written paths) AFTER the final write; a validation older than the write does not count. If the project has no matching script, create the smallest correct test script first, then validate.",
+                    ];
+                }
                 if (item.code === "DIFF_NOT_REVIEWED") {
+                    // In a workspace without Git the git advice is a trap: the model
+                    // searched the catalog for a tool that can never exist and drained
+                    // the turn budget. Point it to the workspace review tool instead.
+                    const activeCanonicalIds = session.toolSet ? Object.values(session.toolSet.canonicalToolIds) : [];
+                    const gitAvailable = activeCanonicalIds.includes("git.diff") || activeCanonicalIds.includes("git.exec");
+                    if (!gitAvailable) {
+                        return [
+                            "DIFF_NOT_REVIEWED next action: this workspace has no Git, so call review_changes (workspace review) once after the last workspace mutation to obtain diff-review evidence. If review_changes reports the change exceeds its size cap, run it again after removing temporary artifacts; output from run_command does not provide trusted diff_review evidence.",
+                        ];
+                    }
                     return [
                         "DIFF_NOT_REVIEWED next action: call git_operation with action 'diff' after the last workspace mutation. If git_operation is not active, first call search_tools with query 'final git diff' and category 'git', then call git_operation on the following turn. Output from run_command, including git diff or git status, does not provide trusted diff_review evidence.",
                     ];
@@ -2708,7 +2839,8 @@ export class AiCoderRunController {
             constraints: Object.freeze([...(session.request.constraints ?? [])]),
             decisions: Object.freeze([...session.evidence.decisions]),
             delivery: Object.freeze({ attachmentsDelivered: session.attachmentsDelivered }),
-            edits: Object.freeze(session.evidence.writes.map((item) => Object.freeze({
+            editsTotal: session.evidence.writes.length,
+            edits: Object.freeze(session.evidence.writes.slice(-500).map((item) => Object.freeze({
                 afterHash: item.afterHash,
                 ...(item.afterKind !== undefined ? { afterKind: item.afterKind } : {}),
                 beforeHash: item.beforeHash,