chainlesschain 0.162.188 → 0.162.189

package/src/data/changelog.json

@@ -1,6 +1,19 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.162.189",
+      "cliVersions": ["0.162.188", "0.162.189"],
+      "date": "2026-07-31",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added — cc CLI 0.162.189: managed rollback and distributed Agent Teams closure",
+          "body": "> `chainlesschain` **0.162.188 → 0.162.189** (2026-07-31).\n> CLI-only release metadata; `@chainlesschain/personal-data-hub` remains\n> **0.4.57** and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Managed workspace rollback**: Process Broker-managed workspace write paths\n  record durable recovery evidence, establish checkpoints at accepted\n  boundaries, and apply fenced rollback after failure, cancellation, or\n  timeout. `full`, `partial`, and `none` coverage outcomes remain explicit,\n  while unsupported external side effects stay outside the rollback guarantee.\n- **Distributed Agent Teams authority**: local schema v6 is the current state\n  authority, with v5 accepted only through CLI-owned resume migration. The\n  separate distributed queue schema v1 uses queue authority digests, leases,\n  and compare-and-swap fences for supported shared-filesystem coordination; it\n  is not a consensus or network-partition-tolerant queue.\n- **Wall-clock lifecycle fence**: linearized `startedAt` and `observedAt`\n  checks surround executor activity, active managed shell and agent work is\n  aborted when the wall-clock budget expires, and commit/checkpoint publication\n  is fenced so late results cannot become completed tasks. Accepted committed\n  evidence instead enters explicit adjudication.\n- **CLI-owned IDE controls**: VS Code and JetBrains surfaces observe the raw\n  local v6 or distributed queue v1 JSON as read-only state and route takeover,\n  recovery, and adjudication through CLI-owned authority, digest, lease, and\n  evidence fences.\n- **Validated implementation candidate**: candidate\n  `7df6feced4670ac71d19548752d18ac4cc225025` completed the\n  [CLI CI](https://github.com/chainlesschain/chainlesschain/actions/runs/30549100935),\n  [CLI Strict Sandbox](https://github.com/chainlesschain/chainlesschain/actions/runs/30549100289),\n  [short distributed soak](https://github.com/chainlesschain/chainlesschain/actions/runs/30549100307),\n  and [long distributed soak](https://github.com/chainlesschain/chainlesschain/actions/runs/30549142504)\n  gates successfully.\n- **Final release-SHA gate remains mandatory**: this version and changelog\n  preparation creates a distinct final release commit. Publication still\n  requires that exact final release SHA to pass the authoritative required\n  matrices; candidate and local results do not authorize publication."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.162.188",

package/src/lib/agent-core.js

@@ -50,6 +50,7 @@ export {
   _anthropicThinkingParams,
   _normalizeAnthropicResponse,
   _resetFileFreshness,
+  _withPostEditDiagnostics,
   _getSharedCodeIntel,
   disposeSharedCodeIntel,
   emitToolHookLifecycle,

package/src/lib/agent-team/task-lease.js

@@ -28,6 +28,11 @@ import { randomUUID } from "node:crypto";
 
 export const DEFAULT_LEASE_TTL_MS = 60000;
 export const DEFAULT_MAX_ATTEMPTS = 3;
+export const ADJUDICATION_DECISIONS = Object.freeze({
+  RETRY: "retry",
+  ACCEPT: "accept",
+  CANCEL: "cancel",
+});
 
 export class TaskLeaseRegistry {
   constructor({
@@ -423,7 +428,14 @@ export class TaskLeaseRegistry {
    */
   fail(
     key,
-    { holder, leaseId, error = null, retryable = true, now = this._now() } = {},
+    {
+      holder,
+      leaseId,
+      error = null,
+      retryable = true,
+      adjudication = null,
+      now = this._now(),
+    } = {},
   ) {
     const id = this._byKey.get(key);
     const task = id ? this._tasks.get(id) : null;
@@ -434,6 +446,23 @@ export class TaskLeaseRegistry {
     }
     const attempts = (task.metadata?.attempts || 0) + 1;
     const willRetry = retryable !== false && attempts < this.maxAttempts;
+    const adjudicationRequest =
+      !willRetry && adjudication && typeof adjudication === "object"
+        ? {
+            required: true,
+            code:
+              adjudication.code ||
+              "TEAM_TASK_SIDE_EFFECT_ADJUDICATION_REQUIRED",
+            reason:
+              adjudication.reason ||
+              (error ? String(error) : "task outcome requires adjudication"),
+            evidenceDigest: adjudication.evidenceDigest || null,
+            requestedAt: Number.isFinite(adjudication.requestedAt)
+              ? adjudication.requestedAt
+              : now,
+            decision: null,
+          }
+        : task.metadata?.adjudication || null;
     const ok = this._write(task, {
       status: willRetry ? TASK_STATUS.PENDING : TASK_STATUS.CANCELLED,
       assignee: null,
@@ -442,6 +471,7 @@ export class TaskLeaseRegistry {
         lease: null,
         attempts,
         lastError: error ? String(error) : null,
+        ...(adjudicationRequest ? { adjudication: adjudicationRequest } : {}),
       },
     });
     if (!ok) return { ok: false, reason: "concurrent" };
@@ -529,6 +559,14 @@ export class TaskLeaseRegistry {
       if (!candidate.retry) {
         metadata.attempts = (fresh.metadata?.attempts || 0) + 1;
         metadata.lastError = String(error);
+        metadata.adjudication = {
+          required: true,
+          code: "TEAM_TASK_ABANDONED_ADJUDICATION_REQUIRED",
+          reason: String(error),
+          evidenceDigest: null,
+          requestedAt: this._now(),
+          decision: null,
+        };
       }
       if (
         this._write(fresh, {
@@ -550,6 +588,234 @@ export class TaskLeaseRegistry {
     return { reclaimed, adjudicationRequired };
   }
 
+  /**
+   * Resolve a fail-closed task after a durable human decision has been
+   * authenticated by the adjudication log.
+   *
+   * This is deliberately the only TaskLeaseRegistry operation allowed to move
+   * a CANCELLED task out of a terminal state. The generic SharedTaskList keeps
+   * its terminal-state invariant; this method performs a compare-by-revision
+   * replacement and records the exceptional transition in task history.
+   */
+  resolveAdjudication(
+    key,
+    {
+      decision,
+      decisionId,
+      actor = "human",
+      reason = null,
+      evidenceDigest = null,
+      result = null,
+      now = this._now(),
+    } = {},
+  ) {
+    const allowed = new Set(Object.values(ADJUDICATION_DECISIONS));
+    if (!allowed.has(decision)) {
+      return { ok: false, reason: "invalid_decision" };
+    }
+    if (!decisionId || typeof decisionId !== "string") {
+      return { ok: false, reason: "decision_id_required" };
+    }
+    const id = this._byKey.get(key);
+    const task = id ? this._tasks.get(id) : null;
+    if (!task) return { ok: false, reason: "not_found" };
+    const pending = task.metadata?.adjudication || null;
+    if (pending?.required !== true) {
+      const prior = pending?.decision || null;
+      if (prior?.id === decisionId && prior?.action === decision) {
+        return {
+          ok: true,
+          idempotent: true,
+          decision,
+          status: task.status,
+        };
+      }
+      return { ok: false, reason: "adjudication_not_required" };
+    }
+    if (task.status !== TASK_STATUS.CANCELLED) {
+      return { ok: false, reason: "invalid_task_state" };
+    }
+    if (pending.evidenceDigest && pending.evidenceDigest !== evidenceDigest) {
+      return { ok: false, reason: "evidence_mismatch" };
+    }
+
+    const status =
+      decision === ADJUDICATION_DECISIONS.RETRY
+        ? TASK_STATUS.PENDING
+        : decision === ADJUDICATION_DECISIONS.ACCEPT
+          ? TASK_STATUS.COMPLETED
+          : TASK_STATUS.CANCELLED;
+    const decidedAt = Number.isFinite(now) ? now : this._now();
+    const decisionRecord = {
+      id: decisionId,
+      action: decision,
+      actor: actor ? String(actor) : "human",
+      reason: reason == null ? null : String(reason),
+      evidenceDigest: evidenceDigest || pending.evidenceDigest || null,
+      decidedAt,
+    };
+    const snapshot = this._tasks.snapshot();
+    const stored = snapshot.tasks.find((candidate) => candidate.id === task.id);
+    if (!stored || stored.rev !== task.rev) {
+      return { ok: false, reason: "concurrent" };
+    }
+    stored.status = status;
+    stored.assignee = null;
+    stored.updatedAt = decidedAt;
+    stored.rev += 1;
+    stored.metadata = {
+      ...stored.metadata,
+      lease: null,
+      ...(decision === ADJUDICATION_DECISIONS.ACCEPT
+        ? {
+            result: result ?? {
+              adjudicated: true,
+              decisionId,
+            },
+          }
+        : {}),
+      adjudication: {
+        ...pending,
+        required: false,
+        decision: decisionRecord,
+      },
+    };
+    stored.history = [
+      ...(stored.history || []),
+      {
+        ts: decidedAt,
+        actor: decisionRecord.actor,
+        action: "adjudicated",
+        changes: ["status", "assignee", "metadata"],
+        decision: decisionRecord.action,
+        decisionId,
+      },
+    ];
+    this._tasks = SharedTaskList.restore(snapshot, { now: this._now });
+    this._rebuildIndexes();
+    if (status === TASK_STATUS.PENDING) {
+      this._enqueueIfReady(key, decidedAt);
+    } else if (status === TASK_STATUS.COMPLETED) {
+      for (const dependent of this._dependentsByKey.get(key) || []) {
+        this._enqueueIfReady(dependent, decidedAt);
+      }
+    }
+    return { ok: true, decision, status };
+  }
+
+  /**
+   * Force any recovery-ambiguous task into the fail-closed adjudication state.
+   * This exceptional transition is used only when durable collaboration
+   * evidence contradicts or weakens the registry snapshot.
+   */
+  requireAdjudication(
+    key,
+    {
+      code = "TEAM_TASK_SIDE_EFFECT_ADJUDICATION_REQUIRED",
+      reason = "task outcome requires adjudication",
+      evidenceDigest = null,
+      now = this._now(),
+    } = {},
+  ) {
+    const id = this._byKey.get(key);
+    const task = id ? this._tasks.get(id) : null;
+    if (!task) return { ok: false, reason: "not_found" };
+    if (task.metadata?.adjudication?.required === true) {
+      return { ok: true, idempotent: true };
+    }
+    const snapshot = this._tasks.snapshot();
+    const stored = snapshot.tasks.find((candidate) => candidate.id === task.id);
+    if (!stored || stored.rev !== task.rev) {
+      return { ok: false, reason: "concurrent" };
+    }
+    const requestedAt = Number.isFinite(now) ? now : this._now();
+    const priorStatus = stored.status;
+    stored.status = TASK_STATUS.CANCELLED;
+    stored.assignee = null;
+    stored.updatedAt = requestedAt;
+    stored.rev += 1;
+    stored.metadata = {
+      ...stored.metadata,
+      lease: null,
+      lastError: String(reason),
+      adjudication: {
+        required: true,
+        code: String(code),
+        reason: String(reason),
+        evidenceDigest: evidenceDigest || null,
+        requestedAt,
+        priorStatus,
+        decision: null,
+      },
+    };
+    stored.history = [
+      ...(stored.history || []),
+      {
+        ts: requestedAt,
+        actor: "recovery",
+        action: "adjudication-required",
+        changes: ["status", "assignee", "metadata"],
+      },
+    ];
+    this._tasks = SharedTaskList.restore(snapshot, { now: this._now });
+    this._rebuildIndexes();
+    return { ok: true, priorStatus };
+  }
+
+  /** Bind a pending adjudication to its immutable durable case evidence. */
+  bindAdjudicationCase(key, { caseId, registryDigest, sideEffectDigest } = {}) {
+    const id = this._byKey.get(key);
+    const task = id ? this._tasks.get(id) : null;
+    if (!task) return { ok: false, reason: "not_found" };
+    const adjudication = task.metadata?.adjudication || null;
+    if (adjudication?.required !== true) {
+      return { ok: false, reason: "adjudication_not_required" };
+    }
+    for (const [name, value] of Object.entries({
+      caseId,
+      registryDigest,
+      sideEffectDigest,
+    })) {
+      if (typeof value !== "string" || value.length === 0) {
+        return { ok: false, reason: `${name}_required` };
+      }
+    }
+    const current = adjudication.case || null;
+    if (current) {
+      if (
+        current.caseId === caseId &&
+        current.registryDigest === registryDigest &&
+        current.sideEffectDigest === sideEffectDigest
+      ) {
+        return { ok: true, idempotent: true, case: { ...current } };
+      }
+      return { ok: false, reason: "case_binding_conflict" };
+    }
+    const binding = { caseId, registryDigest, sideEffectDigest };
+    const ok = this._write(task, {
+      metadata: {
+        ...task.metadata,
+        adjudication: {
+          ...adjudication,
+          case: binding,
+        },
+      },
+    });
+    return ok
+      ? { ok: true, case: { ...binding } }
+      : { ok: false, reason: "concurrent" };
+  }
+
+  pendingAdjudications() {
+    return this.list()
+      .filter((task) => task.metadata?.adjudication?.required === true)
+      .map((task) => ({
+        key: task.key,
+        status: task.status,
+        ...task.metadata.adjudication,
+      }));
+  }
+
   stats({ now = this._now() } = {}) {
     const base = this._tasks.stats();
     let leased = 0;
@@ -566,6 +832,7 @@ export class TaskLeaseRegistry {
       leased,
       expiredLeases: expired,
       claimable: this.claimable({ now }).length,
+      adjudicationRequired: this.pendingAdjudications().length,
     };
   }
 
@@ -575,8 +842,9 @@ export class TaskLeaseRegistry {
       .list()
       .every(
         (t) =>
-          t.status === TASK_STATUS.COMPLETED ||
-          t.status === TASK_STATUS.CANCELLED,
+          (t.status === TASK_STATUS.COMPLETED ||
+            t.status === TASK_STATUS.CANCELLED) &&
+          t.metadata?.adjudication?.required !== true,
       );
   }