@voybio/ace-swarm 2.4.8 → 2.4.10

package/assets/vendor/vericify-reader.mjs

@@ -0,0 +1,272 @@
+// Optional ACE consumer: all history selection remains owned by the Rust reader.
+// No ACE state, process lifecycle, manifest parser or writable store is involved.
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { resolve } from 'node:path';
+
+const execute = promisify(execFile);
+const PROTOCOL = 'vericify-readonly-adapter/v1';
+const U64_MAX = 18446744073709551615n;
+const FAILURE_MESSAGES = Object.freeze({
+  stale_snapshot: 'The native snapshot changed; explicitly begin a new query.',
+  missing_history: 'Native history is missing.',
+  incompatible_protocol: 'Unsupported native adapter protocol or profile.',
+  capacity: 'The native query exceeded its work or output limit.',
+  timeout: 'The native query exceeded its elapsed-time limit.',
+  invalid_query: 'The native query is invalid.',
+  identity_mismatch: 'The native workspace identity does not match the query.',
+  expired: 'The selected native history has expired.',
+  unavailable: 'The native read-only query is unavailable.',
+});
+
+/** Safe failure metadata only. Raw native output and process errors are discarded. */
+export class NativeReadError extends Error {
+  constructor(code, retryable = false, exitCode) {
+    const known = Object.hasOwn(FAILURE_MESSAGES, code) ? code : 'unavailable';
+    const suffix = Number.isInteger(exitCode) ? ` (exit ${exitCode})` : '';
+    super(`Native read-only query failed${suffix}: ${FAILURE_MESSAGES[known]}`);
+    this.name = 'NativeReadError';
+    this.code = known;
+    this.retryable = retryable === true;
+  }
+}
+
+function wireFailure(result, exitCode) {
+  if (result?.protocol !== PROTOCOL || !result?.error || !Object.hasOwn(FAILURE_MESSAGES, result.error.code)
+      || typeof result.error.retryable !== 'boolean') return null;
+  return new NativeReadError(result.error.code, result.error.retryable, exitCode);
+}
+
+function requireValue(condition, message) {
+  if (!condition) {
+    const error = new NativeReadError('unavailable');
+    // Messages at this boundary are fixed validation text, never native values.
+    error.message += ` ${message}`;
+    throw error;
+  }
+}
+function bounded(value, lower, upper, name) {
+  requireValue(Number.isSafeInteger(value) && value >= lower && value <= upper, `${name} is outside its supported bounds`);
+  return String(value);
+}
+function decimal(value) {
+  requireValue(typeof value === 'string' && /^(0|[1-9][0-9]{0,19})$/.test(value) && BigInt(value) <= U64_MAX,
+    'Native reader returned an invalid decimal sequence');
+  return BigInt(value);
+}
+function binding(snapshot) {
+  const value = typeof snapshot === 'string' ? snapshot : snapshot?.binding;
+  requireValue(typeof value === 'string' && /^[0-9a-f]{64}$/.test(value), 'Provide the native snapshot binding from info');
+  return value;
+}
+function identifier(value) {
+  requireValue(typeof value === 'string' && value.length > 0 && value.length <= 512 && !/[\u0000-\u001f\u007f]/.test(value),
+    'Invalid native identity');
+  return value;
+}
+function position(value, snapshot) {
+  requireValue(value?.workspace_id === snapshot.workspace_id && value?.incarnation === snapshot.incarnation,
+    'Native window identity differs from its snapshot');
+  return decimal(value.sequence);
+}
+function canonicalRecord(value, snapshot, type) {
+  identifier(value?.id);
+  if (value.schema_version !== '1') throw new NativeReadError('incompatible_protocol');
+  requireValue(value.workspace_id === snapshot.workspace_id && value.incarnation === snapshot.incarnation,
+    'Native record identity differs from its snapshot');
+  const seq = decimal(value.seq);
+  requireValue(seq > 0n && seq <= decimal(snapshot.high_water), 'Native record sequence exceeds its snapshot');
+  requireValue(value.id === `${snapshot.incarnation}:${value.seq}`, 'Native canonical identity differs from its sequence');
+  if (type) requireValue(value.payload?.record_type === type, 'Native window record type differs from its collection');
+  return seq;
+}
+function decoded(result, maxBytes) {
+  requireValue(result.encoding === 'hex' && typeof result.bytes_hex === 'string' &&
+    result.bytes_hex.length <= maxBytes * 2 && /^(?:[0-9a-f]{2})*$/.test(result.bytes_hex),
+    'Native object exceeds its byte/encoding bound');
+  requireValue(decimal(result.blob.raw_length) === BigInt(result.bytes_hex.length / 2), 'Native object length differs from its canonical reference');
+  return { ...result, bytes: Buffer.from(result.bytes_hex, 'hex') };
+}
+
+/** Uses the installed native executable; ACE needs Node only for this optional client. */
+export function openVericifyHistory({ executable, dataDir, timeoutMs = 15000 }) {
+  requireValue(typeof executable === 'string' && typeof dataDir === 'string', 'Provide an executable and a history directory');
+  bounded(timeoutMs, 1000, 60000, 'timeoutMs');
+  const binary = resolve(executable), directory = resolve(dataDir);
+
+  async function query(action, words = [], expected, outputCap) {
+    let stdout;
+    try {
+      ({ stdout } = await execute(binary, ['adapter', action, '--data-dir', directory, ...words], {
+        encoding: 'utf8', timeout: timeoutMs,
+        maxBuffer: outputCap ?? (action === 'info' ? 16 : action === 'page' ? 1 : 4) * 1024 * 1024 + 65536,
+        windowsHide: true, killSignal: 'SIGKILL',
+      }));
+    } catch (error) {
+      if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') throw new NativeReadError('capacity', true);
+      if (error.killed || error.code === 'ETIMEDOUT') throw new NativeReadError('timeout', true);
+      let result;
+      try { result = JSON.parse(error.stdout); } catch { /* Discard private native text. */ }
+      if (result?.protocol !== undefined && result.protocol !== PROTOCOL) throw new NativeReadError('incompatible_protocol');
+      throw wireFailure(result, error.code) ?? new NativeReadError('unavailable', false, error.code);
+    }
+    let result;
+    try { result = JSON.parse(stdout); } catch { throw new NativeReadError('unavailable'); }
+    if (result?.protocol !== PROTOCOL) throw new NativeReadError('incompatible_protocol');
+    if (result.error) throw wireFailure(result) ?? new NativeReadError('unavailable');
+    const actual = binding(result.snapshot);
+    if (expected) requireValue(actual === expected, 'Native reader mixed history snapshots');
+    decimal(result.snapshot.high_water);
+    return result;
+  }
+
+  return Object.freeze({
+    async info() {
+      return query('info');
+    },
+    /** One native lifetime resolves root identity, canonical changes and later evidence. */
+    async window({ workspaceRoot, fromMs, toMs, after, limit = 100, maxBytes = 262144 }) {
+      requireValue(typeof workspaceRoot === 'string' && workspaceRoot.length > 0 && !workspaceRoot.includes('\0'),
+        'Provide a workspace root for the native window');
+      const from = decimal(fromMs), to = decimal(toMs);
+      requireValue(from <= to, 'Invalid native window time bounds');
+      const words = ['--workspace-root', resolve(workspaceRoot), '--from-ms', fromMs, '--to-ms', toMs,
+        '--limit', bounded(limit, 1, 100, 'limit'), '--max-bytes', bounded(maxBytes, 4096, 1024 * 1024, 'maxBytes')];
+      let start = 0n;
+      if (after !== undefined && after !== null) {
+        identifier(after.workspace_id); identifier(after.incarnation);
+        start = decimal(after.sequence);
+        words.push('--after-sequence', after.sequence, '--workspace-id', after.workspace_id, '--incarnation', after.incarnation);
+      }
+      const result = await query('window', words, undefined, maxBytes);
+      if (result.snapshot.record_profile !== 'vericify/records/v1') throw new NativeReadError('incompatible_protocol');
+      identifier(result.snapshot.workspace_id); identifier(result.snapshot.incarnation);
+      const high = position(result.high_water, result.snapshot), next = position(result.next_after, result.snapshot);
+      const scanned = position(result.scanned_through, result.snapshot);
+      requireValue(high === decimal(result.snapshot.high_water) && start <= next && next <= scanned && scanned <= high,
+        'Native window sequence bounds disagree');
+      const scope = result.query;
+      requireValue(scope?.workspace_id === result.snapshot.workspace_id && scope?.incarnation === result.snapshot.incarnation
+        && (!after || (after.workspace_id === scope.workspace_id && after.incarnation === scope.incarnation)),
+      'Native window query identity differs from its snapshot');
+      requireValue(scope.from_ms === fromMs && scope.to_ms === toMs && decimal(scope.after_sequence) === start,
+        'Native window query differs from the requested window');
+      requireValue(Array.isArray(result.changes) && result.changes.length <= limit && Array.isArray(result.coverage)
+        && Array.isArray(result.host_gaps)
+        && Array.isArray(result.expired_ranges) && Array.isArray(result.evidence?.links)
+        && Array.isArray(result.evidence.host) && Array.isArray(result.evidence.purposes)
+        && Array.isArray(result.evidence.unavailable), 'Invalid native window collections');
+      requireValue(typeof result.scan_complete === 'boolean' && typeof result.evidence.complete === 'boolean'
+        && result.scan_complete === (scanned === high)
+        && (result.evidence.complete ? next === scanned : next === start)
+        && result.complete === (result.scan_complete && result.evidence.complete),
+      'Native window completion disagrees with its progress or evidence');
+      const expired = result.expired_ranges.length > 0 || result.evidence.unavailable.some(item => item?.reason === 'expired');
+      requireValue(['complete', 'pending', 'expired'].includes(result.state)
+        && (result.state !== 'complete' || (result.complete && !expired))
+        && (result.state !== 'pending' || !result.complete)
+        && (result.state !== 'expired' || (result.complete && expired)), 'Invalid native window state');
+      const changes = new Map();
+      for (const item of result.changes) {
+        canonicalRecord(item.record, result.snapshot, 'observed_file_change');
+        requireValue(!changes.has(item.record.id), 'Native window repeated a change identity');
+        const data = item.record.payload.data;
+        const observedFrom = decimal(data?.observed_from), observedTo = decimal(data?.observed_to);
+        requireValue(observedFrom <= observedTo && observedFrom <= to && observedTo >= from,
+          'Native change is outside the requested window');
+        if (item.latest_link !== null) {
+          const seq = canonicalRecord(item.latest_link, result.snapshot, 'change_evidence_link');
+          requireValue(item.latest_link.payload.data?.change_id === item.record.id && seq > decimal(item.record.seq),
+            'Native enrichment does not name its observed change');
+        }
+        changes.set(item.record.id, item.latest_link);
+      }
+      const links = new Map();
+      for (const link of result.evidence.links) {
+        canonicalRecord(link, result.snapshot, 'change_evidence_link');
+        requireValue(changes.has(link.payload.data?.change_id) && !links.has(link.id), 'Native evidence contains unrelated enrichment');
+        links.set(link.id, link);
+      }
+      for (const link of changes.values()) if (link !== null) {
+        requireValue(links.has(link.id) && JSON.stringify(links.get(link.id)) === JSON.stringify(link),
+          'Native enrichment differs from its canonical evidence');
+      }
+      for (const [records, type] of [[result.coverage, 'coverage_event'], [result.evidence.host, 'host_evidence'],
+        [result.evidence.purposes, 'purpose_evidence']]) {
+        for (const record of records) canonicalRecord(record, result.snapshot, type);
+      }
+      for (const gap of result.host_gaps) {
+        canonicalRecord(gap, result.snapshot, 'host_evidence');
+        const observedAt = decimal(gap.payload.data?.observed_at);
+        requireValue(gap.payload.data?.kind === 'observation_gap' && observedAt >= from && observedAt <= to,
+          'Native host gap is outside its kind or requested time window');
+      }
+      for (const missing of result.evidence.unavailable) { identifier(missing?.id); identifier(missing?.reason); }
+      let previous = 0n;
+      for (const range of result.expired_ranges) {
+        const first = decimal(range.first), last = decimal(range.last);
+        requireValue(first > previous && first <= last && last <= high, 'Native window expiry sequence bounds disagree');
+        previous = last;
+      }
+      return result;
+    },
+    async page({ snapshot, cursor, limit = 128, maxBytes = 262144 }) {
+      const expected = binding(snapshot);
+      const words = ['--snapshot', expected, '--limit', bounded(limit, 1, 1024, 'limit'),
+        '--max-bytes', bounded(maxBytes, 4096, 1024 * 1024, 'maxBytes')];
+      if (cursor !== undefined && cursor !== null) {
+        requireValue(typeof cursor === 'string' && cursor.length > 0 && cursor.length <= 4096, 'Invalid native cursor');
+        words.push('--cursor', cursor);
+      }
+      const result = await query('page', words, expected);
+      requireValue(Array.isArray(result.records) && Array.isArray(result.expired_ranges), 'Invalid native page');
+      const start = decimal(result.after_sequence), end = decimal(result.through_sequence);
+      requireValue(start <= end && end <= decimal(result.snapshot.high_water), 'Native page sequence bounds disagree');
+      let previous = start;
+      for (const record of result.records) {
+        const sequence = decimal(record.seq);
+        requireValue(sequence > previous && sequence <= end, 'Native records lost their global sequence order');
+        requireValue(record.workspace_id === result.snapshot.workspace_id && record.incarnation === result.snapshot.incarnation,
+          'Native record belongs to another history');
+        previous = sequence;
+      }
+      requireValue(typeof result.complete === 'boolean', 'Native page omitted completion state');
+      requireValue(result.complete === (end === decimal(result.snapshot.high_water)), 'Native completion does not match its high-water sequence');
+      const coverage = [...result.records.map(record => ({ first: decimal(record.seq), last: decimal(record.seq) })),
+        ...result.expired_ranges.map(range => ({ first: decimal(range.first), last: decimal(range.last) }))]
+        .sort((a, b) => a.first < b.first ? -1 : 1);
+      requireValue(coverage.length <= limit, 'Native page exceeds its entry bound');
+      let through = start;
+      for (const entry of coverage) {
+        requireValue(entry.first === through + 1n && entry.last >= entry.first && entry.last <= end,
+          'Native page contains an overlapping or unexplained history gap');
+        through = entry.last;
+      }
+      requireValue(through === end && (result.complete || end > start), 'Native page omitted coverage or progress');
+      requireValue(result.complete ? result.next_cursor === null : typeof result.next_cursor === 'string' && result.next_cursor.length > 0,
+        'Native page omitted its continuation');
+      return result;
+    },
+    async object({ snapshot, changeId, side = 'after', maxBytes = 2 * 1024 * 1024 }) {
+      const expected = binding(snapshot);
+      requireValue(typeof changeId === 'string' && changeId.length > 0 && changeId.length <= 512, 'Provide a canonical change ID');
+      requireValue(['before', 'after', 'patch'].includes(side), 'Unsupported retained object side');
+      const result = await query('object', ['--snapshot', expected, '--change-id', changeId, '--side', side,
+        '--max-bytes', bounded(maxBytes, 1, 2 * 1024 * 1024, 'maxBytes')], expected);
+      requireValue(result.record_id === changeId && result.side === side && result.encoding === 'hex', 'Native object does not bind this selection');
+      return decoded(result, maxBytes);
+    },
+    async blob({ snapshot, recordId, digest, maxBytes = 2 * 1024 * 1024 }) {
+      const expected = binding(snapshot);
+      requireValue(typeof recordId === 'string' && recordId.length > 0 && recordId.length <= 512, 'Provide a canonical record ID');
+      requireValue(typeof digest === 'string' && /^[0-9a-f]{64}$/.test(digest), 'Provide a canonical BLAKE3 digest');
+      const result = await query('object', ['--snapshot', expected, '--record-id', recordId, '--blob-digest', digest,
+        '--max-bytes', bounded(maxBytes, 1, 2 * 1024 * 1024, 'maxBytes')], expected);
+      requireValue(result.record_id === recordId && result.side === null && result.blob?.digest === digest,
+        'Native blob does not bind this retained record');
+      return decoded(result, maxBytes);
+    },
+  });
+}
+
+export { PROTOCOL };

package/assets/vendor/vericify-reader.provenance.json

@@ -0,0 +1,10 @@
+{
+  "source": "vericify/integrations/ace/vericify-reader.mjs",
+  "protocol": "vericify-readonly-adapter/v1",
+  "sha256": "e7d8e7b864e42426d89a7a5c418f2e75f5cdd6c7fd6af4d3114e00cbe1f8ed69",
+  "vendor_policy": "Exact maintained read-only client bytes; update only by explicit source comparison. No sibling checkout at runtime.",
+  "license": "Apache-2.0",
+  "source_commit": "2cc636ceb19e48c01891957afac446db131ba16f",
+  "license_file": "LICENSE",
+  "license_authorization": "Authorized by the Vericify owner on 2026-10-21 for distribution of this reader file only, inside @voybio/ace-swarm under the package Apache-2.0 LICENSE. No other Vericify source, binary or package is licensed by this record."
+}

package/dist/ace-autonomy.d.ts

@@ -1,3 +1,61 @@
+import type { GoalRecord } from './store/repositories/goal-repository.js';
+import type { TaskPlan } from './orchestrator-supervisor.js';
+export interface CurrentWorkItem {
+    kind: "goal_step" | "todo" | "handoff";
+    id: string;
+    title: string;
+    goal_id?: string;
+    assignee?: string;
+    since?: string;
+    last_ace_call_at?: string;
+    reason?: string;
+    job_id?: string;
+    handoff_id?: string;
+    trace_id?: string;
+}
+export interface CurrentWork {
+    state: "active" | "waiting" | "blocked" | "ready" | "completed" | "none" | "ambiguous";
+    objective?: {
+        text: string;
+        source: "goal" | "task_md";
+        goal_id?: string;
+    };
+    doing: CurrentWorkItem[];
+    next: CurrentWorkItem[];
+    blocked: CurrentWorkItem[];
+    waiting: CurrentWorkItem[];
+    other_goals: {
+        goal_id: string;
+        objective: string;
+        updated_at: string;
+    }[];
+    last_completed?: {
+        text: string;
+        at?: string;
+    };
+    sources: string[];
+    issues?: string[];
+    idle_learning?: string;
+    pending_learning_approval?: number;
+}
+export interface CurrentWorkInput {
+    workspaceRoot?: string;
+    goal_id?: string;
+    agent?: string;
+    goal_snapshot?: {
+        goal: GoalRecord;
+        plan: TaskPlan;
+    };
+}
+/** Canonical records only; never initializes state or writes a projection. */
+export declare function resolveCurrentWork(input?: CurrentWorkInput): CurrentWork;
+export declare function formatCurrentWork(work: CurrentWork, mode: "line" | "block"): string;
+/** Select related events by identifiers; source records are never changed. */
+export declare function readCurrentWorkContext(input?: CurrentWorkInput): {
+    work: CurrentWork;
+    events: import("./status-events.js").StatusEventRecord[];
+    entries: import("./run-ledger.js").RunLedgerEntry[];
+};
 export declare const ACE_TASK_CONTRACT_FILES: readonly ["agent-state/TASK.md", "agent-state/SCOPE.md", "agent-state/QUALITY_GATES.md", "agent-state/HANDOFF.json"];
 export declare const ACE_DEFAULT_STATE_SOURCES: readonly ["agent-state/TASK.md", "agent-state/SCOPE.md", "agent-state/QUALITY_GATES.md", "agent-state/STATUS.md", "agent-state/HANDOFF.json", "agent-state/EVIDENCE_LOG.md"];
 export declare const ACE_DEFAULT_CONTINUITY_SOURCES: readonly ["agent-state/TASK.md", "agent-state/SCOPE.md", "agent-state/QUALITY_GATES.md", "agent-state/HANDOFF.json", "agent-state/STATUS.md", "agent-state/DECISIONS.md", "agent-state/RISKS.md", "agent-state/EVIDENCE_LOG.md"];

package/dist/ace-autonomy.js

@@ -1,8 +1,210 @@
+import { readLearningPolicy } from './learning-policy.js';
 import { resolveWorkspaceRoot, safeRead, wsPath } from "./helpers.js";
 import { readRunLedger } from "./run-ledger.js";
 import { isReadError } from "./shared.js";
 import { readStatusEvents } from "./status-events.js";
-import { getWorkspaceStorePath, readStoreJsonSync, storeExistsSync, toVirtualStorePath, } from "./store/store-snapshot.js";
+import { getWorkspaceStorePath, readStoreJsonSync, listStoreKeysSync, storeExistsSync, toVirtualStorePath, } from "./store/store-snapshot.js";
+import { readStoreBlobSync } from "./store/store-snapshot.js";
+import { readAceLogicalFile } from "./ace-state-resolver.js";
+import { GoalRepository } from "./store/repositories/goal-repository.js";
+import { getReadyTaskSteps } from "./task-plan-context.js";
+import { readHandoffRegistry } from "./handoff-registry.js";
+import { withWorkspaceRoot } from "./helpers/workspace-root.js";
+import { createHash } from "node:crypto";
+import { deriveLinkedTodo } from './linked-work.js';
+function workText(value, length = 120) {
+    const text = value.replace(/\s+/g, " ").trim();
+    if (text.length <= length)
+        return text;
+    const prefix = text.slice(0, length - 1);
+    return `${prefix.slice(0, Math.max(0, prefix.lastIndexOf(" ")))}…`;
+}
+/** Canonical records only; never initializes state or writes a projection. */
+export function resolveCurrentWork(input = {}) {
+    const root = input.workspaceRoot ?? resolveWorkspaceRoot();
+    return withWorkspaceRoot(root, () => {
+        const work = { state: "none", doing: [], next: [], blocked: [], waiting: [], other_goals: [], sources: [] };
+        const repo = new GoalRepository(root);
+        const goals = repo.listGoals();
+        if (input.goal_snapshot) {
+            const g = input.goal_snapshot.goal;
+            const index = goals.findIndex(row => row.goal_id === g.goal_id);
+            const entry = { goal_id: g.goal_id, status: g.status, objective: g.objective, updated_at: g.updated_at };
+            if (index < 0)
+                goals.push(entry);
+            else
+                goals[index] = entry;
+        }
+        const active = goals.filter((g) => g.goal_id !== "G-learning" && ["executing", "verifying", "blocked"].includes(g.status));
+        const stopped = goals.filter(g => g.goal_id !== 'G-learning' && g.status === 'stopped');
+        const stoppedIds = new Set(stopped.map(g => g.goal_id));
+        const matched = input.agent ? active.filter((g) => repo.getPlan(g.goal_id)?.steps.some((s) => s.status === "running" && s.assignee === input.agent)) : [];
+        const selected = input.goal_id && input.goal_id !== "G-learning" ? goals.find((g) => g.goal_id === input.goal_id) : matched.length === 1 ? matched[0] : active.length === 1 ? active[0] : active.length === 0 && stopped.length === 1 ? stopped[0] : undefined;
+        const ambiguous = !selected && active.length > 1;
+        work.other_goals = active.filter((g) => g.goal_id !== selected?.goal_id).map((g) => ({ goal_id: g.goal_id, objective: g.objective, updated_at: g.updated_at }));
+        if (selected?.status === "done") {
+            work.last_completed = { text: selected.objective, at: selected.updated_at };
+        }
+        else if (selected) {
+            work.objective = { text: selected.objective, source: "goal", goal_id: selected.goal_id };
+            work.sources.push(`goal:${selected.goal_id}@${selected.updated_at}`);
+            const plan = input.goal_snapshot?.goal.goal_id === selected.goal_id ? input.goal_snapshot.plan : repo.getPlan(selected.goal_id);
+            if (!plan)
+                work.issues = [`Plan unavailable for ${selected.goal_id}`];
+            const ready = new Set(plan ? getReadyTaskSteps(plan).map((s) => s.step_id) : []);
+            for (const step of plan?.steps ?? []) {
+                if (selected.status === 'stopped')
+                    continue;
+                const extra = step;
+                const item = { kind: "goal_step", id: step.step_id, title: workText(step.task.split(/\r?\n/)[0]), goal_id: selected.goal_id, assignee: extra.assignee, since: extra.started_at, reason: extra.waiting_on ?? step.blocked_reason, job_id: step.job_id, handoff_id: step.handoff_id, trace_id: extra.trace_id };
+                if (step.status === "running") {
+                    item.last_ace_call_at = step.last_ace_call_at ?? step.started_at;
+                    work.doing.push(item);
+                }
+                else if (step.status === "blocked" || step.status === "failed")
+                    (extra.waiting_on ? work.waiting : work.blocked).push(item);
+                else if (ready.has(step.step_id))
+                    work.next.push(item);
+            }
+            if (selected.status === "blocked" && work.blocked.length === 0)
+                work.blocked.push({ kind: "goal_step", id: selected.goal_id, goal_id: selected.goal_id, title: selected.objective, reason: repo.getGoal(selected.goal_id)?.reason_code ?? "Goal is blocked" });
+        }
+        else if (input.goal_id && input.goal_id !== "G-learning") {
+            work.issues = [`Unknown goal: ${input.goal_id}`];
+        }
+        for (const goal of stopped)
+            work.waiting.push({ kind: 'goal_step', id: goal.goal_id, goal_id: goal.goal_id,
+                title: `stopped ${goal.goal_id}`, reason: 'user:resume' });
+        const registry = readHandoffRegistry();
+        const hasHandoffRecords = listStoreKeysSync(root, "state/handoffs/").some((key) => key !== "state/handoffs/index");
+        const handoffs = hasHandoffRecords ? registry.handoffs : readStoreJsonSync(root, "state/artifacts/agent-state/handoff-registry.json")?.handoffs ?? registry.handoffs;
+        if (Object.keys(handoffs).length)
+            work.sources.push("state/handoffs");
+        for (const handoff of Object.values(handoffs)) {
+            if (handoff.step_ref && stoppedIds.has(handoff.step_ref.goal_id))
+                continue;
+            const item = { kind: "handoff", id: handoff.handoff_id, title: workText(handoff.title), assignee: handoff.to, since: handoff.updated_at };
+            if (handoff.status === "accepted")
+                work.doing.push(item);
+            else if (handoff.status === "open")
+                work.waiting.push(item);
+            else if (handoff.status === "blocked")
+                work.blocked.push({ ...item, reason: handoff.history?.at(-1)?.note });
+        }
+        const ids = readStoreJsonSync(root, "state/todo/index");
+        const legacyTodos = ids === undefined ? readStoreJsonSync(root, "state/artifacts/agent-state/todo-state.json") : undefined;
+        const todos = (ids ? ids.map((id) => readStoreJsonSync(root, `state/todo/${id}`)).filter((t) => !!t) : Object.values(legacyTodos?.nodes ?? {})).map(t => deriveLinkedTodo(t, root, input.goal_snapshot));
+        if (todos.length)
+            work.sources.push("state/todo");
+        const completed = new Set(todos.filter((t) => t.status === "done").map((t) => t.id));
+        for (const todo of todos) {
+            if (todo.step_ref && stoppedIds.has(todo.step_ref.goal_id))
+                continue;
+            const item = { kind: "todo", id: todo.id, title: workText(todo.title), assignee: todo.assigned_to, reason: todo.notes };
+            if (todo.status === "in_progress")
+                work.doing.push(item);
+            else if (["blocked", "gated"].includes(todo.status))
+                work.blocked.push(item);
+            else if (["pending", "backlog"].includes(todo.status) && (todo.depends_on ?? []).every((id) => completed.has(id)))
+                work.next.push(item);
+        }
+        if (active.length === 0 && !input.goal_id && !selected) {
+            const task = readStoreBlobSync(root, "state/artifacts/agent-state/TASK.md") ?? readAceLogicalFile(root, "agent-state/TASK.md");
+            if (task?.trim()) {
+                const objective = task.match(/^##\s+Objective[^\n]*\n+([^#\n][^\n]*)/im)?.[1]?.trim() ?? task.split(/\r?\n/).map((line) => line.trim()).find((line) => line && !line.startsWith("#") && !/^-\s+\[/.test(line)) ?? task.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? "Workspace task";
+                const criteria = [...task.matchAll(/^\s*-\s+\[([ xX])\]/gm)];
+                work.sources.push(`task_md:sha256:${createHash("sha256").update(task).digest("hex")}`);
+                if (criteria.length > 0 && criteria.every((m) => m[1].toLowerCase() === "x")) {
+                    const status = readStoreBlobSync(root, "state/artifacts/agent-state/STATUS.md") ?? readAceLogicalFile(root, "agent-state/STATUS.md") ?? "";
+                    work.last_completed = { text: objective, at: status.split("\n").find((l) => /complet|release|verif/i.test(l))?.match(/\d{4}-\d{2}-\d{2}/)?.[0] };
+                }
+                else
+                    work.objective = { text: objective, source: "task_md" };
+            }
+            if (!work.last_completed && !work.objective) {
+                const done = goals.find((g) => g.goal_id !== "G-learning" && g.status === "done");
+                if (done)
+                    work.last_completed = { text: done.objective, at: done.updated_at };
+            }
+        }
+        const learningPolicy = readLearningPolicy(root);
+        if (learningPolicy.issue && !work.doing.length && !work.next.length)
+            work.idle_learning = `idle · learning unavailable: ${workText(learningPolicy.issue, 120)}`;
+        if (learningPolicy.enabled && !work.doing.length && !work.next.length) {
+            const pending = repo.getPlan('G-learning')?.steps.find(s => ['planned', 'running'].includes(s.status));
+            const proposed = listStoreKeysSync(root, 'knowledge/').filter(k => k.endsWith('/LEARNED.md') || /\/references\/proposals\/[^/]+\.md$/.test(k)).filter(k => /^status: proposed$/m.test(readStoreBlobSync(root, k) ?? ''));
+            if (proposed.length)
+                work.pending_learning_approval = proposed.length;
+            const learningGoal = repo.getGoal('G-learning');
+            if (learningGoal?.status === 'blocked' && !pending)
+                work.idle_learning = `idle · learning blocked: ${workText(learningGoal.reason_code ?? 'inspect G-learning', 100)}`;
+            if (pending)
+                work.idle_learning = `idle · 1 learning step available (${pending.step_id}: ${workText(pending.learning_scope ?? pending.task, 70)})`;
+        }
+        work.state = ambiguous ? "ambiguous" : work.issues?.length ? "blocked" : work.doing.length ? "active" : work.next.length ? "ready" : work.blocked.length ? "blocked" : work.waiting.length ? "waiting" : work.objective ? "ready" : work.last_completed ? "completed" : "none";
+        return work;
+    });
+}
+export function formatCurrentWork(work, mode) {
+    if (mode === "line") {
+        const current = work.state === "ambiguous" ? `${work.other_goals.length} active goals (${work.other_goals.map((g) => g.goal_id).join(", ")}); choose goal_id` : work.objective ? `${work.objective.goal_id ?? ""} ${work.objective.text}`.trim() : work.doing.length || work.next.length || work.waiting.length || work.blocked.length ? "workspace work" : "no active work";
+        // Bound the objective independently so it cannot erase the current step.
+        const subject = work.doing.length || work.next.length || work.waiting.length ? workText(current, 110) : current;
+        const wait = work.waiting[0];
+        const waitTitle = wait?.reason === 'user:resume' && wait.goal_id === work.objective?.goal_id ? 'stopped' : wait?.title;
+        return workText(`ACE now: ${subject}${work.doing[0] ? ` · doing ${work.doing[0].id} ${workText(work.doing[0].title, 70)}` : ""}${work.next[0] ? ` · next ${work.next[0].id} ${work.next[0].title}` : ""}${work.blocked.length ? ` · ${work.blocked.length} blocked` : ""}${wait ? ` · waiting ${waitTitle}${wait.reason === 'user:resume' ? ' [user:resume]' : ''}` : ""}${work.issues?.length ? ` · ${work.issues.join("; ")}` : ""}${work.idle_learning ? ` · ${work.idle_learning}` : ""}${work.last_completed ? ` · last objective completed${work.last_completed.at ? ` ${work.last_completed.at}` : ""} (${work.last_completed.text})` : ""}`, 220);
+    }
+    const lines = [formatCurrentWork(work, "line")];
+    if (work.idle_learning)
+        lines.push(work.idle_learning);
+    if (work.pending_learning_approval)
+        lines.push(`${work.pending_learning_approval} learned instruction/overlay awaiting operator approval`);
+    if (work.last_completed)
+        lines.push(`Last objective completed${work.last_completed.at ? ` ${work.last_completed.at}` : ""}: ${work.last_completed.text}`);
+    if (work.objective)
+        lines.push(`Objective: ${work.objective.text}`);
+    for (const [label, items] of [["Doing", work.doing.slice(0, 3)], ["Next", work.next.slice(0, 3)], ["Blocked", work.blocked.slice(0, 5)], ["Waiting", work.waiting.slice(0, 5)]]) {
+        for (const item of items)
+            lines.push(`${label}: ${item.id} ${item.title}${item.assignee ? ` (${item.assignee})` : ""}${item.since ? ` [last touched ${item.since}${Date.now() - Date.parse(item.since) > 86400000 ? '; stale' : ''}]` : ""}${item.last_ace_call_at ? ` [step age ${Math.max(0, Math.floor((Date.now() - Date.parse(item.since ?? item.last_ace_call_at)) / 60000))}m; last ACE call ${item.last_ace_call_at}; host progress unobserved]` : ''}${item.reason ? ` — ${workText(item.reason, 220)}` : ""}`);
+    }
+    if (work.other_goals.length)
+        lines.push(`Other goals: ${work.other_goals.map((g) => `${g.goal_id} ${g.objective}`).join("; ")}`);
+    for (const issue of work.issues ?? [])
+        lines.push(`Context incomplete: ${issue}`);
+    return lines.join("\n");
+}
+/** Select related events by identifiers; source records are never changed. */
+export function readCurrentWorkContext(input = {}) {
+    const root = input.workspaceRoot ?? resolveWorkspaceRoot();
+    return withWorkspaceRoot(root, () => {
+        const work = resolveCurrentWork({ ...input, workspaceRoot: root });
+        const items = [...work.doing, ...work.next, ...work.blocked, ...work.waiting];
+        const goalIds = new Set(work.objective?.goal_id ? [work.objective.goal_id] : work.other_goals.map((g) => g.goal_id));
+        const ids = new Set(items.flatMap((i) => [i.id, i.job_id, i.handoff_id, i.trace_id]).filter((v) => !!v));
+        const active = goalIds.size > 0 || items.length > 0;
+        const related = (row) => {
+            const record = row;
+            const fields = { ...record, ...(coerceObject(record.payload) ?? {}), ...(coerceObject(record.metadata) ?? {}) };
+            const linkedGoal = readString(fields.goal_id) ?? readString(fields.objective_id);
+            // Step names are only unique within a goal. A sibling goal's S1 is not our S1.
+            if (linkedGoal && goalIds.size && !goalIds.has(linkedGoal))
+                return false;
+            if (linkedGoal && goalIds.has(linkedGoal))
+                return true;
+            const directLink = ["handoff_id", "todo_id", "job_id", "trace_id"].some((key) => typeof fields[key] === "string" && ids.has(fields[key]));
+            if (directLink)
+                return true;
+            if (active)
+                return false;
+            // With no active work, show recent state transitions with work identity.
+            return ["step_id", "todo_id", "handoff_id"].some((key) => typeof fields[key] === "string") &&
+                ["status", "from_status", "to_status", "previous_status", "next_status", "from", "to"].some((key) => typeof fields[key] === "string");
+        };
+        const events = readStatusEvents(Number.MAX_SAFE_INTEGER).filter(related);
+        const entries = readRunLedger().entries.filter(related);
+        return { work, events, entries };
+    });
+}
 export const ACE_TASK_CONTRACT_FILES = [
     "agent-state/TASK.md",
     "agent-state/SCOPE.md",
@@ -369,7 +571,9 @@ export function buildAceContinuityPacket(input) {
         });
         usedChars += excerpt.length;
     }
+    const context = readCurrentWorkContext();
     const highlights = [
+        formatCurrentWork(context.work, "block"),
         recall.task_contract.summary,
         ...(recall.task_contract.blockers.length > 0
             ? recall.task_contract.blockers
@@ -382,16 +586,17 @@ export function buildAceContinuityPacket(input) {
             ? [`Missing ${missingSources.length} configured state sources.`]
             : []),
     ];
-    const recentStatusEvents = readStatusEvents(policy.max_status_events).map((event) => ({
+    const linkedFailures = context.events.filter((event) => ["fail", "blocked"].includes(event.status));
+    const visibleEvents = [...new Map([...context.events.slice(-policy.max_status_events), ...linkedFailures].map((event) => [event.event_id, event])).values()];
+    const recentStatusEvents = visibleEvents.reverse().map((event) => ({
         timestamp: event.timestamp,
         source_module: event.source_module,
         event_type: event.event_type,
         status: event.status,
         summary: readString(coerceObject(event.payload)?.summary) ?? event.event_type,
     }));
-    const ledger = readRunLedger();
-    const recentRunLedger = ledger.entries
-        .slice(Math.max(0, ledger.entries.length - policy.max_run_ledger_entries))
+    const recentRunLedger = context.entries
+        .slice(-policy.max_run_ledger_entries).reverse()
         .map((entry) => ({
         timestamp: entry.timestamp_utc,
         tool: entry.tool,
@@ -410,7 +615,7 @@ export function buildAceContinuityPacket(input) {
     }
     return {
         generated_at: new Date().toISOString(),
-        summary: `ACE continuity packet includes ${includedSources.length}/${recall.state_slices.length} configured state sources.`,
+        summary: formatCurrentWork(context.work, "line"),
         highlights,
         task_contract_ok: recall.task_contract.ok,
         blockers: [...recall.task_contract.blockers],

package/dist/ace-internal-tools.d.ts

@@ -6,5 +6,6 @@ export interface AceInternalToolCatalogEntry {
 export declare function listAceInternalToolCatalog(): AceInternalToolCatalogEntry[];
 export declare function executeAceInternalTool(name: string, input: Record<string, unknown> | undefined, sessionId?: string, options?: {
     workspace_path?: string;
+    signal?: AbortSignal;
 }): Promise<any>;
 //# sourceMappingURL=ace-internal-tools.d.ts.map

package/dist/ace-internal-tools.js

@@ -23,9 +23,9 @@ function summarizeSchemaKeys(schema) {
     }
     return [];
 }
-function buildRequestExtra(sessionId) {
+function buildRequestExtra(sessionId, signal) {
     return {
-        signal: new AbortController().signal,
+        signal: signal ?? new AbortController().signal,
         sessionId,
         requestId: randomUUID(),
         sendNotification: async () => undefined,
@@ -75,7 +75,7 @@ export async function executeAceInternalTool(name, input, sessionId, options = {
             isError: true,
         };
     }
-    const extra = buildRequestExtra(sessionId);
+    const extra = buildRequestExtra(sessionId, options.signal);
     if (tool.inputSchema) {
         return tool.handler(parsedInput.data, extra);
     }

package/dist/ace-server-instructions.d.ts

@@ -3,9 +3,9 @@ export declare function buildAceDigest(workspaceRoot: string): string;
 export declare function buildServerInstructions(workspaceRoot: string): string;
 export declare function buildHostInstructionText(host: "claude" | "copilot" | "cursor" | "codex", workspaceRoot: string): string;
 export declare function buildBootstrapNudge(workspaceRoot: string): string;
-export declare function buildBootstrapGuidance(workspaceRoot: string, toolName: string): string;
-export declare function buildMutationGuidance(workspaceRoot: string, toolName: string): string;
-export declare function buildRefreshGuidance(workspaceRoot: string, toolName: string): string;
+export declare function buildBootstrapGuidance(workspaceRoot: string, _toolName: string): string;
+export declare function buildMutationGuidance(workspaceRoot: string, _toolName: string): string;
+export declare function buildRefreshGuidance(workspaceRoot: string, _toolName: string): string;
 export declare function installAceToolGovernance(server: McpServer, workspaceRoot: string): void;
 export declare function buildHookAdditionalContext(workspaceRoot: string): string;
 export declare function buildScopeReminder(workspaceRoot: string): string | undefined;