@kynver-app/runtime 0.1.76 → 0.1.77

package/dist/completion-replay.d.ts

@@ -0,0 +1,10 @@
+import type { HarnessWorkerRecord } from "./status.js";
+/**
+ * A finished worker whose completion POST was recorded but did not advance the
+ * linked AgentTask (structural blocker or rejected outcome) must be eligible for
+ * idempotent completion replay on later pipeline ticks — not skipped as "already
+ * acknowledged".
+ */
+export declare function shouldReplayHarnessCompletion(worker: HarnessWorkerRecord): boolean;
+/** Terminal ack with no structural reason to replay completion to AgentOS. */
+export declare function hasTerminalCompletionAck(worker: HarnessWorkerRecord): boolean;

package/dist/index.js

@@ -1863,7 +1863,9 @@ function computeWorkerStatus(worker, options = {}) {
     finalResult,
     error,
     changedFiles,
-    gitAncestry
+    gitAncestry,
+    instructionPolicyFingerprint: worker.instructionPolicyFingerprint ?? null,
+    instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null
   };
 }
 function isFinishedWorkerStatus(status) {
@@ -3670,6 +3672,21 @@ function persistCompletionAck(worker, runId, fields) {
   saveWorker(runId, worker);
 }
 
+// src/completion-replay.ts
+function trimBlocker(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+}
+function shouldReplayHarnessCompletion(worker) {
+  if (trimBlocker(worker.completionBlocker)) return true;
+  if (worker.completionOutcome === "rejected") return true;
+  return false;
+}
+function hasTerminalCompletionAck(worker) {
+  return hasCompletionAck(worker) && !shouldReplayHarnessCompletion(worker);
+}
+
 // src/worker-ops.ts
 import path17 from "node:path";
 
@@ -4488,7 +4505,7 @@ async function tryCompleteWorker(args) {
     return { ok: true, skipped: true, reason: "worker-not-finished" };
   }
   const forceReplay = args.force === true || args.force === "true";
-  if (!forceReplay && hasCompletionAck(worker)) {
+  if (!forceReplay && hasTerminalCompletionAck(worker)) {
     return {
       ok: true,
       skipped: true,
@@ -4880,7 +4897,7 @@ async function autoCompleteWorker(raw) {
       reason: "worker has no agentOsId/taskId \u2014 nothing to attribute completion to"
     };
   }
-  if (hasCompletionAck(worker)) {
+  if (hasTerminalCompletionAck(worker)) {
     return {
       worker: worker.name,
       runId: worker.runId,
@@ -4893,7 +4910,7 @@ async function autoCompleteWorker(raw) {
   const startMs = Date.now();
   while (true) {
     worker = loadWorker(args.run, args.name);
-    if (hasCompletionAck(worker)) {
+    if (hasTerminalCompletionAck(worker)) {
       return {
         worker: worker.name,
         runId: worker.runId,
@@ -6192,7 +6209,23 @@ async function dispatchRun(args) {
     for (const decision of result.started) {
       shouldContinueDispatch = await spawnClaimed(decision) && shouldContinueDispatch;
     }
-    skipped.push(...result.skipped ?? []);
+    skipped.push(
+      ...result.skipped ?? []
+    );
+    if (exactTargetMode) {
+      for (const skipDecision of skipped) {
+        const taskId = String(skipDecision.task.id);
+        if (!exactTargetIds.has(taskId)) continue;
+        outcomes.push({
+          taskId,
+          started: false,
+          error: `exact_target_not_started:${skipDecision.skipReason}`,
+          skipReason: skipDecision.skipReason,
+          detail: skipDecision.reason ?? null,
+          requestedTargetTaskIds: [...exactTargetIds]
+        });
+      }
+    }
     if (exactTargetMode) shouldContinueDispatch = false;
     while (shouldContinueDispatch && outcomes.length < cappedStarts) {
       if (exactTargetMode) break;
@@ -8931,6 +8964,24 @@ async function runPipelineDispatch(args, slots) {
   };
 }
 
+// src/pipeline-exact-targets.ts
+function operatorExactTargetTaskIds(operatorTick) {
+  if (!operatorTick || typeof operatorTick !== "object") return [];
+  const body = operatorTick;
+  const raw = body.response?.dispatch?.exactTargetTaskIds;
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of raw) {
+    if (typeof value !== "string") continue;
+    const id = value.trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+
 // src/pipeline-max-starts.ts
 function operatorDispatchFromTick(operatorTick) {
   const body = operatorTick;
@@ -9090,7 +9141,7 @@ async function completeFinishedWorkers(runId, args) {
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
-    if (hasCompletionAck(worker)) {
+    if (hasTerminalCompletionAck(worker)) {
       outcomes.push({ worker: name, ok: true, taskId: worker.taskId ?? null, skipped: true });
       continue;
     }
@@ -9159,24 +9210,50 @@ async function runPipelineTick(args) {
   let maxStarts = maxStartsAdvice.maxStarts;
   const sweep = await sweepRun({ run: runId, agentOsId, pipeline: true, ...args });
   let dispatch = null;
-  if (execute && maxStarts > 0) {
-    dispatch = await runPipelineDispatch(
+  let startedCount = 0;
+  const exactTargetTaskIds = operatorExactTargetTaskIds(operatorTick);
+  let remainingStarts = maxStarts;
+  if (execute && remainingStarts > 0 && exactTargetTaskIds.length > 0) {
+    const exactBudget = Math.min(remainingStarts, exactTargetTaskIds.length);
+    const exact = await runPipelineDispatch(
+      {
+        ...args,
+        run: runId,
+        agentOsId,
+        targetTaskIds: exactTargetTaskIds.join(",")
+      },
+      exactBudget
+    );
+    const exactStarted = countDispatchStarts(exact);
+    startedCount += exactStarted;
+    remainingStarts = Math.max(0, remainingStarts - exactStarted);
+    dispatch = { exactTargetTaskIds, exact, startedCount };
+  }
+  if (execute && remainingStarts > 0) {
+    const broad = await runPipelineDispatch(
       {
         ...args,
         run: runId,
         agentOsId
       },
-      maxStarts
+      remainingStarts
     );
-  } else {
-    dispatch = {
-      ok: true,
-      skipped: true,
-      reason: execute ? dispatchResourceGate.reason ?? "no slots or queued work" : "execute disabled",
-      maxStarts: 0
-    };
+    const broadStarted = countDispatchStarts(broad);
+    startedCount += broadStarted;
+    dispatch = dispatch && typeof dispatch === "object" ? { ...dispatch, broad, startedCount } : broad;
+  } else if (!execute || maxStarts <= 0) {
+    if (!dispatch) {
+      dispatch = {
+        ok: true,
+        skipped: true,
+        reason: execute ? dispatchResourceGate.reason ?? "no slots or queued work" : "execute disabled",
+        maxStarts: 0,
+        ...exactTargetTaskIds.length ? { exactTargetTaskIds, exactOnly: true } : {}
+      };
+    }
+  } else if (dispatch && typeof dispatch === "object") {
+    dispatch = { ...dispatch, broadSkipped: true, startedCount };
   }
-  const startedCount = dispatch?.startedCount ?? 0;
   const idle = !maxStartsAdvice.underutilized && maxStarts === 0 && completedWorkers.length === 0 && startedCount === 0;
   return {
     runId,