@sagentlab/navarch-runtime 0.1.91 → 0.1.92

package/dist/conversation/workspace.cjs

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conversationEnv = conversationEnv;
+exports.validRepositoryUrl = validRepositoryUrl;
+exports.conversationRoot = conversationRoot;
+exports.prepareConversationWorkspace = prepareConversationWorkspace;
+exports.removeConversationWorkspace = removeConversationWorkspace;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const sandbox_cjs_1 = require("../sandbox.cjs");
+const journal_cjs_1 = require("./journal.cjs");
+const CLONE_TIMEOUT_MS = 3 * 60_000;
+const REPOSITORY_MARKER = "repository-url";
+/** Variables that carry this runtime's own or a task's credentials, never a conversation's. */
+const WITHHELD_ENV = /^(NAVARCH_|GH_|GITHUB_|GIT_ASKPASS$|SSH_ASKPASS$|SSH_AUTH_SOCK$)/;
+/**
+ * Environment for a conversation child. It inherits the machine's own login
+ * (HOME, PATH, provider keys the local agent needs) but not the Navarch
+ * machine token, broker or GitHub credentials the runtime holds for tasks.
+ */
+function conversationEnv(base = process.env) {
+    const env = {};
+    for (const [key, value] of Object.entries(base)) {
+        if (value === undefined || WITHHELD_ENV.test(key))
+            continue;
+        env[key] = value;
+    }
+    return env;
+}
+/**
+ * Maps the project's stored repository value to a GitHub https clone URL.
+ * The control plane stores a free-form value; the task path accepts
+ * `owner/name`, `git@github.com:owner/name(.git)` and `https://github.com/...`
+ * (lib/navarch/github-repository.ts), and so does this one. Anything else
+ * (another host, `ext::`, `file:`, `-` options, embedded credentials) returns
+ * null, so the runtime never hands an unvalidated string to git.
+ */
+function validRepositoryUrl(value) {
+    if (typeof value !== "string" || value.length > 2048 || /[\s\0]/.test(value))
+        return null;
+    const fullName = value
+        .replace(/^git@github\.com:/i, "")
+        .replace(/^https:\/\/github\.com\//i, "")
+        .replace(/\.git$/i, "")
+        .replace(/\/+$/, "");
+    if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(fullName) || fullName.startsWith("-"))
+        return null;
+    return `https://github.com/${fullName}.git`;
+}
+function conversationRoot(workspaceRoot, conversationId) {
+    return node_path_1.default.join(workspaceRoot, "conversations", (0, journal_cjs_1.assertUuid)(conversationId, "conversation id"));
+}
+/**
+ * Prepares the conversation's own checkout. Each conversation gets a separate
+ * directory, so two conversations never share files, history or git config.
+ * The first turn clones; later turns of the same conversation reuse the
+ * checkout so a follow-up sees the same revision as the first answer.
+ *
+ * The clone uses the machine's own git credentials (the same ones a local
+ * `git clone` would use), never a Navarch server-side provider credential.
+ * A repository this machine cannot read fails the turn instead of falling back.
+ */
+async function prepareConversationWorkspace(options) {
+    const url = validRepositoryUrl(options.repositoryUrl);
+    if (!url)
+        throw new Error("repository URL is not a plain https URL");
+    const runner = options.runner ?? sandbox_cjs_1.nodeCommandRunner;
+    const root = conversationRoot(options.workspaceRoot, options.conversationId);
+    const workspace = {
+        root,
+        checkout: node_path_1.default.join(root, "repo"),
+        metaDir: node_path_1.default.join(root, "meta"),
+    };
+    await node_fs_1.promises.mkdir(workspace.metaDir, { recursive: true, mode: 0o700 });
+    const marker = node_path_1.default.join(root, REPOSITORY_MARKER);
+    const recorded = await node_fs_1.promises.readFile(marker, "utf8").catch(() => null);
+    const hasCheckout = await node_fs_1.promises.stat(node_path_1.default.join(workspace.checkout, ".git")).then(() => true, () => false);
+    if (hasCheckout && recorded === url)
+        return workspace;
+    // New conversation, a changed repository URL, or an interrupted clone.
+    await node_fs_1.promises.rm(workspace.checkout, { recursive: true, force: true });
+    const env = {
+        ...options.env,
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_ALLOW_PROTOCOL: "https",
+        GIT_CONFIG_COUNT: "1",
+        GIT_CONFIG_KEY_0: "core.hooksPath",
+        GIT_CONFIG_VALUE_0: process.platform === "win32" ? "NUL" : "/dev/null",
+    };
+    const result = await runner.run("git", ["clone", "--quiet", "--filter=blob:none", "--no-tags", "--", url, workspace.checkout], { cwd: root, env, timeoutMs: CLONE_TIMEOUT_MS, signal: options.signal });
+    if (result.code !== 0) {
+        await node_fs_1.promises.rm(workspace.checkout, { recursive: true, force: true }).catch(() => undefined);
+        throw new Error(`git clone failed with exit ${result.code}: ${result.stderr.slice(-500)}`);
+    }
+    await node_fs_1.promises.writeFile(marker, url, { encoding: "utf8", mode: 0o600 });
+    return workspace;
+}
+async function removeConversationWorkspace(workspaceRoot, conversationId) {
+    await node_fs_1.promises.rm(conversationRoot(workspaceRoot, conversationId), { recursive: true, force: true });
+}

package/dist/prompt.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderPrompt = renderPrompt;
 exports.renderGuidanceCorrectionPrompt = renderGuidanceCorrectionPrompt;
+exports.renderCompletionRemediationPrompt = renderCompletionRemediationPrompt;
 exports.renderHostedCheckpointNote = renderHostedCheckpointNote;
 const CODE_GRAPH_GUIDANCE = "For JS/TS dependency inspection, the runtime provides `navarch-runtime code-graph --query <symbol-or-file> --mode search|callers|callees|impact --commit HEAD`. If the runtime is not on PATH, use its installed entry point; do not install another copy mid-task. Results describe committed source and include commit/freshness warnings; inspect current files for uncommitted changes and unresolved dependencies.";
 const PROCESS_GUIDANCE = "Process management: this host may run other agent sessions. Keep the PID or tool handle of each preview server you start and stop only that owned process. Never use broad process-name or command-line matching (pkill, killall) to clean up servers: the agent launcher carries the task prompt in its arguments and can match those patterns, terminating your own session. Use a different port when a port is occupied by a process you do not own. Keep scratch files in the current worktree; paths in previous transcripts belong to earlier sessions.";
@@ -74,6 +75,40 @@ function renderGuidanceCorrectionPrompt(originalPrompt, guidance) {
         "",
     ].join("\n");
 }
+/** Keeps a long previous report from crowding the brief out of the prompt. */
+const REMEDIATION_REPORT_LIMIT = 8_000;
+/**
+ * Builds the turn that follows a remediable completion rejection (for example
+ * `verification_verdict_invalid` or `pr_required`). Each turn is a fresh agent
+ * invocation with no memory of the last one, so the rejection alone gave the
+ * agent nothing to act on: a verifier answered BLOCKED because it had "no
+ * acceptance criteria or task to verify". The turn therefore carries the full
+ * task brief, the rejection, and the previous turn's report.
+ */
+function renderCompletionRemediationPrompt(args) {
+    const report = args.previousReport.trim();
+    const clipped = report.length > REMEDIATION_REPORT_LIMIT
+        ? `${report.slice(0, REMEDIATION_REPORT_LIMIT)}\n\n[... truncated]`
+        : report;
+    return [
+        args.originalPrompt.trim(),
+        "",
+        "## Completion was rejected",
+        "",
+        "Your previous turn on this task finished, but the Navarch control plane rejected its completion:",
+        "",
+        ...args.rejection.trim().split("\n").map((line) => `> ${line}`),
+        "",
+        `This is correction turn ${args.attempt} of ${args.maxAttempts}. The task above is unchanged, and you are in the`,
+        "same worktree, so earlier edits, commits, and branches are still here. Reuse the work and findings from",
+        "the previous turn instead of starting over, fix what the rejection names, and finish the task.",
+        "Your final report replaces the previous one, so restate it in full in the required format.",
+        ...(clipped
+            ? ["", "### Previous turn's final report", "", clipped]
+            : []),
+        "",
+    ].join("\n");
+}
 /**
  * Tells the agent its worktree starts from a hosted attempt's checkpoint
  * (GitWorktree.restoredHostedCheckpoint), mirroring the hosted side's own

package/dist/session.cjs

@@ -523,10 +523,12 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             activeAbortController = new AbortController();
             if (leaseLost || deps.shutdownSignal?.aborted)
                 activeAbortController.abort();
-            const runPrompt = nextPrompt ??
-                (deliveredGuidance.length > (bundle.guidance?.length ?? 0)
-                    ? (0, prompt_cjs_1.renderGuidanceCorrectionPrompt)(promptText, deliveredGuidance)
-                    : promptText);
+            // The task brief plus any mid-flight guidance. Correction turns build on
+            // this rather than on the previous turn's prompt so they never nest.
+            const briefPrompt = deliveredGuidance.length > (bundle.guidance?.length ?? 0)
+                ? (0, prompt_cjs_1.renderGuidanceCorrectionPrompt)(promptText, deliveredGuidance)
+                : promptText;
+            const runPrompt = nextPrompt ?? briefPrompt;
             nextPrompt = null;
             await node_fs_1.promises.writeFile(node_path_1.default.join(workDir, "prompt.md"), runPrompt, "utf8");
             adapterStarted = true;
@@ -780,7 +782,15 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 if (remediable && completionRemediationRetries < COMPLETION_REMEDIATION_RETRIES) {
                     completionRemediationRetries += 1;
                     log.warn(`completion for ${leaseId} needs more work; restarting agent turn ${completionRemediationRetries}/${COMPLETION_REMEDIATION_RETRIES} in the same worktree.`);
-                    nextPrompt = redactedRejection;
+                    // A new turn is a fresh agent invocation: the rejection alone would
+                    // reach an agent that has never seen the task.
+                    nextPrompt = (0, prompt_cjs_1.renderCompletionRemediationPrompt)({
+                        originalPrompt: briefPrompt,
+                        rejection: redactedRejection,
+                        previousReport: redactedReport,
+                        attempt: completionRemediationRetries,
+                        maxAttempts: COMPLETION_REMEDIATION_RETRIES,
+                    });
                     continue;
                 }
                 if (remediable) {

package/dist/update-coordinator.cjs

@@ -53,11 +53,12 @@ class RuntimeUpdateCoordinator {
         void this.applyRestart(directive);
     }
     async applyRestart(directive) {
-        const { heartbeat, claimLoop, capacity } = this.options;
+        const { heartbeat, claimLoop, conversationLoop, capacity } = this.options;
         try {
             heartbeat.setUpdateState("draining");
             log.info(`remote restart ${directive.command_id} received; draining active sessions`);
             await claimLoop.drain();
+            await conversationLoop?.drain();
             await capacity.waitForIdle();
             log.info(`remote restart ${directive.command_id} ready; handing off to supervisor`);
             (this.options.requestRestart ?? ((code) => process.exit(code)))(supervisor_cjs_1.REMOTE_RESTART_EXIT_CODE);
@@ -67,6 +68,7 @@ class RuntimeUpdateCoordinator {
             log.error(`remote restart failed: ${message}`);
             heartbeat.setUpdateState("failed", message.slice(0, 500));
             claimLoop.start();
+            conversationLoop?.start();
             this.restartInProgress = null;
         }
     }
@@ -74,7 +76,7 @@ class RuntimeUpdateCoordinator {
         return (this.options.now ?? Date.now)();
     }
     async apply(directive) {
-        const { config, heartbeat, claimLoop, capacity } = this.options;
+        const { config, heartbeat, claimLoop, conversationLoop, capacity } = this.options;
         try {
             heartbeat.setUpdateState("staging");
             log.info(`staging runtime ${directive.target_version}`);
@@ -82,6 +84,7 @@ class RuntimeUpdateCoordinator {
             heartbeat.setUpdateState("draining");
             log.info("runtime update staged; draining active sessions before restart");
             await claimLoop.drain();
+            await conversationLoop?.drain();
             await capacity.waitForIdle();
             await (0, update_installer_cjs_1.writePendingUpdate)(config.configDir, staged, directive.rollout_id);
             log.info(`runtime ${directive.target_version} ready; handing off to supervisor`);
@@ -96,6 +99,7 @@ class RuntimeUpdateCoordinator {
             log.error(`runtime update failed: ${message} (retrying ${directive.target_version} in ${Math.round(delayMs / 1000)}s)`);
             heartbeat.setUpdateState("failed", message.slice(0, 500));
             claimLoop.start();
+            conversationLoop?.start();
             this.targetInProgress = null;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.91",
+  "version": "0.1.92",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",