@sagentlab/navarch-runtime 0.1.63 → 0.1.65

package/README.md

@@ -6,6 +6,11 @@ it. Plain Node/TypeScript, no Next.js coupling, and no shared app-code coupling
 — this directory is a self-contained package you can `npx` on any fresh
 machine.
 
+During a connected run, the runtime reports preparation, agent start, output
+activity, and completion checks to the control plane. Project members can see
+these phase updates in the task view. The activity signal contains no prompt
+or CLI output; the redacted transcript is uploaded when the run finishes.
+
 The machine operator selects **Claude Code**, **OpenAI Codex**, **Google
 Gemini CLI**, **OpenCode**, or an **Agent Client Protocol (ACP)** agent when connecting a worker. Any selected agent can
 run any unpinned project task; task eligibility depends on capabilities and

package/dist/api.cjs

@@ -141,6 +141,10 @@ class NavarchApiClient {
             throw new Error("heartbeatLease: empty response from control plane.");
         return result;
     }
+    /** Best-effort, lease-scoped activity signal for connected machines. */
+    async reportActivity(leaseId, phase) {
+        await this.request("POST", `/api/dispatch/${encodeURIComponent(leaseId)}/activity`, { phase }, { allowEmpty: true });
+    }
     /** schema-design.md §7 — `POST /api/dispatch/:leaseId/complete {status, report, evidence_urls, cost}`. */
     async completeLease(leaseId, req) {
         await this.request("POST", `/api/dispatch/${encodeURIComponent(leaseId)}/complete`, req, {

package/dist/session.cjs

@@ -94,7 +94,7 @@ async function runSession(deps, claimed, sessionId) {
         await api
             .completeLease(leaseId, {
             status: "failed",
-            report: verificationFailureReport(task.task_type, failureSummary, "crashed"),
+            report: failureSummary,
             failure_summary: failureSummary,
             failed_before_start: true,
             evidence_urls: [],
@@ -174,7 +174,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         const failureSummary = `Project ${task.project_id} has no GitHub repository URL. Set it in Project settings before dispatching work.`;
         await api.completeLease(leaseId, {
             status: "failed",
-            report: verificationFailureReport(task.task_type, failureSummary, "crashed"),
+            report: failureSummary,
             failure_summary: failureSummary,
             failed_before_start: true,
             evidence_urls: [],
@@ -296,7 +296,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         await api
             .completeLease(leaseId, {
             status: "failed",
-            report: verificationFailureReport(task.task_type, "Docker sandbox unavailable on this machine.", "crashed"),
+            report: "Docker sandbox unavailable on this machine.",
             failure_summary: "Docker sandbox unavailable on this machine.",
             failed_before_start: true,
             evidence_urls: [],
@@ -395,6 +395,23 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
     // session actually produced instead of zeroing it.
     let lastCompletion = null;
     let adapterStarted = false;
+    // Activity is metadata only: no prompt, model output, or secret-bearing CLI
+    // text crosses this path. Failures never affect lease ownership or delivery.
+    let activityPending = Promise.resolve();
+    let outputObservedAt = 0;
+    let outputReportedAt = 0;
+    let adapterRunning = false;
+    const reportActivity = (phase) => {
+        activityPending = activityPending.then(() => api.reportActivity(leaseId, phase)).catch((error) => {
+            log.warn(`activity update failed for ${leaseId}: ${(0, redact_cjs_1.redactText)(String(error), registry.list())}`);
+        });
+    };
+    const activityTimer = setInterval(() => {
+        if (adapterRunning && outputObservedAt > outputReportedAt && Date.now() - outputReportedAt >= 60_000) {
+            outputReportedAt = Date.now();
+            reportActivity("output");
+        }
+    }, 15_000);
     const heartbeatGuard = new lease_heartbeat_cjs_1.LeaseHeartbeatGuard(claimed.expires_at, () => {
         log.warn(`confirmed lease expired for ${leaseId} without renewal — killing session.`);
         leaseLost = true;
@@ -407,6 +424,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         abortForRuntimeShutdown();
     lifecycle.enteredMainSessionTry = true;
     try {
+        reportActivity("preparing");
         await gitWorktree.prepare();
         if (gitWorktree.hostedCheckpointRestoreFailure) {
             log.warn(`hosted checkpoint for ${leaseId} could not be restored: ` +
@@ -465,6 +483,8 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             nextPrompt = null;
             await node_fs_1.promises.writeFile(node_path_1.default.join(workDir, "prompt.md"), runPrompt, "utf8");
             adapterStarted = true;
+            adapterRunning = true;
+            reportActivity("running");
             const remainingRuntimeMs = maxRuntimeMs > 0
                 ? maxRuntimeMs - (node_perf_hooks_1.performance.now() - agentBudgetStartedAt)
                 : 0;
@@ -488,8 +508,10 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                     cwd: gitWorktree.worktreePath,
                     dockerExec: sandbox ? { containerName: sandbox.name, runner: sandbox_cjs_1.nodeCommandRunner } : undefined,
                     signal: activeAbortController.signal,
+                    onActivity: () => { outputObservedAt = Date.now(); },
                 }, task.idle_timeout_ms ?? config.sessionIdleTimeoutMs ?? 45 * 60_000, runtime === "opencode" ? config.opencodeStartupTimeoutMs : 0);
             activeAbortController = null;
+            adapterRunning = false;
             if (turnResult.timedOut || leaseLost)
                 await checkpointForRecovery(turnResult);
             if (turnResult.model) {
@@ -497,6 +519,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 executionReport = { ...executionReport, model: turnResult.model };
             }
             attempts.push(turnResult);
+            reportActivity("finishing");
             const capacityLimit = (0, adapter_capacity_cjs_1.detectAdapterCapacityLimit)(turnResult);
             if (capacityLimit) {
                 await checkpointForRecovery(turnResult);
@@ -634,9 +657,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             const redactedReport = (0, redact_cjs_1.redactText)(mapping.reportSummary, knownSecrets);
             const completion = {
                 status: mapping.leaseOutcome,
-                report: mapping.leaseOutcome === "failed"
-                    ? verificationFailureReport(task.task_type, redactedReport, mapping.exitStatus)
-                    : redactedReport,
+                report: redactedReport,
                 evidence_urls: mapping.evidenceUrls,
                 ...(deliveryFailureSummary
                     ? { failure_summary: (0, redact_cjs_1.redactText)(deliveryFailureSummary, knownSecrets) }
@@ -698,9 +719,9 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                     await api.completeLease(leaseId, {
                         ...completion,
                         status: "failed",
-                        report: verificationFailureReport(task.task_type, remediable
+                        report: remediable
                             ? redactedRejection
-                            : `${redactedRejection}\n\n---\n\n${completion.report}`, "failed"),
+                            : `${redactedRejection}\n\n---\n\n${completion.report}`,
                         failure_summary: redactedRejection,
                         exit_status: "failed",
                     });
@@ -732,9 +753,9 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         await api
             .completeLease(leaseId, {
             status: "failed",
-            report: verificationFailureReport(task.task_type, lastCompletion
+            report: lastCompletion
                 ? `${lastCompletion.report}\n\n---\n\n${failureSummary}`
-                : failureSummary, "crashed"),
+                : failureSummary,
             failure_summary: failureSummary,
             failed_before_start: !adapterStarted,
             evidence_urls: lastCompletion?.evidence_urls ?? [],
@@ -752,6 +773,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         deps.shutdownSignal?.removeEventListener("abort", abortForRuntimeShutdown);
         sessionClosing = true;
         clearInterval(heartbeatTimer);
+        clearInterval(activityTimer);
         heartbeatGuard.stop();
         activeAbortController?.abort();
         // Drain only an already-started filesystem update, never a stalled network
@@ -815,33 +837,6 @@ function sumReportedUsage(attempts, key) {
     });
     return reported.length > 0 ? reported.reduce((sum, value) => sum + value, 0) : undefined;
 }
-/**
- * The control plane refuses to release a verify lease whose failed completion
- * does not open with `Verification verdict: FAIL` or `BLOCKED`
- * (verification_verdict_invalid), and that gate applies to runtime-authored
- * failure reports too. When the report carries no usable verdict — the agent
- * exited non-zero, or opened with PASS despite the failed outcome — label it
- * BLOCKED: the failure prevented an acceptance decision. Without this, the
- * failure completion is itself rejected, the session crashes, and the lease
- * dangles until expiry.
- *
- * A `killed` or `crashed` exit is left unlabelled: the control plane accepts
- * those verdict-less as the runtime's own failure and routes them through
- * failure attribution (an infrastructure retry). A BLOCKED label there would
- * misreport a transient timeout as a verifier verdict and escalate it to a
- * human; the control plane discards such a label, so posting it only muddies
- * the session report.
- */
-function verificationFailureReport(taskType, report, exitStatus) {
-    if (taskType !== "verify")
-        return report;
-    if (exitStatus === "killed" || exitStatus === "crashed")
-        return report;
-    const verdict = (0, exit_conditions_cjs_1.leadingVerificationVerdict)(report);
-    if (verdict === "fail" || verdict === "blocked")
-        return report;
-    return `Verification verdict: BLOCKED — the session ended before verification reached an acceptance decision.\n\n${report}`;
-}
 /** Rejection codes another agent turn in the same worktree can plausibly fix. */
 const REMEDIABLE_REJECTION_CODES = new Set([
     "review_fix_required",
@@ -871,7 +866,7 @@ const REMEDIABLE_REJECTION_CODES = new Set([
     // `Verification verdict:` line only has to restate its report; the
     // rejection prose spells out the exact format. Failed outcomes never reach
     // remediation (see the leaseOutcome === "completed" gate) — their reports
-    // are verdict-labelled by verificationFailureReport before posting.
+    // are recorded as session failures when the verifier supplied no verdict.
     "verification_verdict_invalid",
 ]);
 /**

package/package.json

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