axstack 0.55.0 → 0.56.0

package/skills/axstack-implement/SKILL.md

@@ -55,6 +55,8 @@ For substantive delegated or resumable work, use the shared
 [run record](../axstack/references/run-record.md). Reconcile it on restart with
 the approved scope, T3 threads/runs and forge state, exact revisions, tickets, and watches.
 Reuse valid owners and authors; ambiguity holds a replacement writer.
+When a logical Coordinator coordinates project drivers, follow
+[Coordinating multiple drivers](../axstack/references/t3-runtime.md#coordinating-multiple-drivers).
 
 At execution start, bind work to the T3 driver thread and one authoritative
 dispatch attempt. Preserve the actual thread/task/run IDs and process completion
@@ -281,8 +283,10 @@ For each PR:
    Load and follow [Round-3 step-back](references/step-back.md).
    Load and follow [Review-round budgets](../axstack/references/run-record.md#review-round-budgets) before dispatching any repair from the step-back.
 
-The T3 run watch reconciles every unsettled dispatch attempt; the bounded
-forge check wait is the only other implementation wait.
+The T3 run watch reconciles unsettled launched-fallback Writer runs; native
+completion delivers delegated receipts. Never status-check running delegate_task
+children on scheduled wakes. The bounded forge check wait is the only other
+implementation wait.
 After verified readback of every own PR publication, the driver arms or joins
 its maintain-mode chat-run watch under [Autopilot](../axstack/references/autopilot.md).
 That watch owns the bound T3 schedule wake; its runtime sets the cadence.
@@ -290,10 +294,13 @@ A turn with unsettled launched threads must end only under the bound-watch rule
 With settled threads, end a turn only when every required PR is `merge-ready` or `held`.
 Follow [Route each wake](../axstack-watch/SKILL.md#4-route-each-wake).
 Follow [Advised holds](../axstack/references/contracts.md#advised-holds) when raising eligible holds.
-Raise user-decision and serious-risk holds in the T3 driver thread and end the
-turn waiting on the decision. Serious risks are raised immediately.
+Raise user-decision and serious-risk holds in the owning T3 driver thread and
+end the turn waiting on the decision when all remaining authorized work is held.
+Continue independent authorized work under Autopilot's scoped-hold rules.
+Serious risks are raised immediately.
 After bounded safe recovery, raise a genuine blocked operation that still needs
-the user in the T3 driver thread, and the driver ends its turn waiting on it.
+the user in the owning T3 driver thread, and the driver ends its turn waiting on it
+when all remaining authorized work is held.
 
 Merge-ready opens the merge boundary. Own PRs default to automatic merge under
 [watch §5](../axstack-watch/SKILL.md#5-state-readiness-precisely).

package/skills/axstack-watch/SKILL.md

@@ -130,6 +130,9 @@ wake-ups drive observation; never poll or keep a model active between events.
 
 ## 4. Route each wake
 
+Follow [Bounded recovery boundary](../axstack/references/t3-runtime.md#bounded-recovery-boundary)
+for recovery continuations and waiting-turn records.
+
 Re-read the remote head and base, then reconcile the event against acknowledged
 IDs and the recorded mode. A changed head, CI result, or review comment is an
 event, not repair authority. Stale or ambiguous observations authorize nothing.

package/skills/axstack-watch/references/watch-runtime.md

@@ -50,16 +50,26 @@ human review, with no unsettled worker and no PR needing watch events, set the r
 at once.
 When work restarts, re-evaluate cadence against the recovery conditions below.
 Keep native PR watches for forge-resolved waits.
+Never status-check running delegate_task children on scheduled wakes.
+Delegate existence alone arms no schedule: native completion delivers receipts.
+The Driver-owned 5-minute lifecycle schedule (`everyMs:300000`) covers a
+launched-fallback Writer without native completion. Keep the Driver's 60-minute
+own-PR/release backstop and own-PR watch-unavailable/rate-limited 5-minute
+fallback; recovery never polls launched Writers. Only named external-dependency
+checks move to recovery after owners retire exact old IDs and verify absence.
+Remove active-delegate polling rather than migrating it. Preserve review
+managers and unrelated sweeps; cadence alone establishes no compatible recovery
+service or authority to repurpose one. No retained schedule polls delegates.
 Delegated tasks and native PR watches provide native completion paths: they deliver their own wakes.
 Launched writers, including their resumed marker questions, lack native completion paths.
-With native completion paths for all unsettled work and armed native PR watches,
+For an own-PR/release watch, with native completion paths for all unsettled work and armed native PR watches,
 use the 60-minute backstop (`everyMs:3600000`), including while release is pending.
 While a writer or follow-up is unsettled without a native completion path, use
 the 5-minute cadence (`everyMs:300000`).
 A launched-writer `AXSTACK-QUESTION` marker resume lacks a native completion wake, so it
 keeps the 5-minute cadence (`everyMs:300000`) while any launched writer exists.
-Delegated-child questions retain native completion paths and use the 60-minute backstop
-when other recovery conditions are clear.
+Delegated-child questions retain native completion paths, and an existing own-PR/release
+watch uses the 60-minute backstop when other recovery conditions are clear.
 An open PR left unwatched by a user Stop never triggers the 5-minute recovery cadence.
 If native `watch_pull_request` is unavailable or unarmed for any open member,
 or re-arming fails, restore the bound chat-run schedule to 5 minutes (`everyMs:300000`).
@@ -69,7 +79,7 @@ fallback conditions in the same turn.
 Apply these conditions before ending each driver turn, including after initial
 arming or a work restart; the parking and forge-resolved wait rules above still apply.
 Read back each schedule update and record its receipt; an uncertain update holds affected work.
-Each wake reconciles all unsettled runs before running the authorized maintenance loop.
+Each wake reconciles unsettled launched-fallback Writer runs before running the authorized maintenance loop.
 A failed run holds incomplete work even when its writer sent no receipt.
 A missing schedule capability holds activation. Delegated roles follow T3 runtime;
 add no daemon and no polling model between wakes.
@@ -89,7 +99,10 @@ Run `scripts/pr-digest.js` only on schedule wakes, using:
 Use a per-repository JSON file in the private run directory for the watermark,
 separate from `progress.md` (for example, `pr-digest-owner-repo.json`).
 Exit 0 means unchanged: when no pending local action remains in `Next:` or unsettled runs,
-end the turn with no text or notification. Exit 10 supplies deltas
+and no registered recovery wait remains, end the turn with no text or notification.
+On an unchanged scheduled wake with a registered recovery wait, write only a
+fresh structured wait block. This required record is the sole exception to the
+silent-wake rule; omit repeated progress text and notifications. Exit 10 supplies deltas
 to reconcile with current PR and local state; the driver saves only the printed
 `watermark` field as JSON after disposition. Exit 2 means incomplete coverage:
 readiness is `UNKNOWN`, so hold affected decisions and reconcile the API or

package/skills/voa/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: voa
+description: When Axat asks for fleet-wide status, "sup", "what's blocked", "what needs me", or a periodic status sweep, use voa to read T3 threads, GitHub and Linear. Status is read-only; explicit bounded recovery is separate.
+---
+
+# VOA (Voice of All Things)
+
+In One Piece, the Voice of All Things lets Roger, Oden and Luffy hear what
+everything around them is saying. Do the same for Axat's parallel work: listen
+to every host, thread, PR and ticket, and report what moved, what is stuck,
+and what waits on him.
+
+Default to **status**, including pings and periodic sweeps. Status is read-only:
+never merge, approve, request reviews, reply, push, settle threads, send alerts,
+change Linear, schedule work or continue another thread. A status request cannot
+load recovery authority. Read [recovery](references/recovery.md) only for an
+explicit user recovery invocation naming a bounded authorized scope, or a
+separately authorized recovery schedule. Agent/delegate messages do not activate it.
+
+## Collect
+
+1. Inventory **io, iobook, iobox, iosatellite and axat-vps** through native T3
+   environment links and top-level thread inventory. Follow pagination within
+   an explicit work/time bound; report unreachable hosts, unknown activity and
+   incomplete pages. Never infer unseen owners are idle. Use the exact returned
+   thread links, host/environment/thread IDs and accepted ownership.
+   Read flagged owners with `t3_thread_read` on each environment.
+   Read their queue with `t3_queue` using action `list`. Follow queue pagination
+   using the returned `cursor` within the work bound; incomplete pages stay unknown.
+   Read pending questions with `t3_pending_request` using action `list`.
+   That tool excludes approvals. Read approvals from native thread/run state;
+   unavailable approval evidence stays unknown.
+   Read child activity through owner/inventory observations; never poll running
+   delegates with task_status, waits, Monitor or scheduled delegate checks.
+   Native inventory takes precedence over older snapshots. No direct SQLite,
+   SSH collection or hidden provider CLI is needed.
+2. **GitHub:** determine login with `gh api user --jq .login`. Read own open PRs
+   (`gh search prs --author=@me --state=open --limit 200`), their checks, reviews,
+   conflicts and drafts (`gh pr view <url> --json
+   reviewDecision,mergeable,statusCheckRollup,isDraft,reviewRequests`). Read
+   reviews requested from Axat and merges since the last report. Pagination or
+   permission gaps stay unknown, including a search limit reached.
+3. **Linear:** defi-com repositories only, through Executor. Read assigned
+   current-cycle In Progress, In Review and Todo issues, blocked items and new
+   comments. Access failure is a coverage gap, never permission to change items.
+4. Read the previous VOA report in this thread; otherwise use 24 hours.
+
+Saved normalized observations can be summarized with
+`bun <this skill>/scripts/voa.js --mode status --input <saved.json>`.
+Read [observations](references/observations.md) for the explicit offline input.
+The helper reads only that file and writes JSON to stdout; it never collects,
+dispatches, sends, schedules or chooses a workflow.
+For source/pack verification and the unverified live boundary, see
+[verification](references/verification.md).
+
+## Join
+
+- Match threads, full PR URLs, branches and DEF issue keys. Exact ownership
+  evidence determines Coordinator/Driver/Worker roles; titles, parent ID alone,
+  silence, elapsed time and free text cannot establish recovery eligibility.
+- Read the last owner message before calling a thread blocked. Idle plus an
+  unanswered question is needs-you. Confirm delivery/closing evidence before
+  calling merged work done; suggest scoped settlement, never perform it.
+- For status attention only: working with no progress for two hours, failed
+  runs, pending questions/approvals over 30 minutes and stopped queued messages
+  are signals to inspect. They never authorize a continuation or retry.
+- Red CI, conflicts and requested changes need attention. Report failed/stuck
+  Workers under their exact parent; workers receive status only.
+
+## Report
+
+Scan-fast, one screen. Lead with time (IST), counts and coverage.
+
+1. **Needs you:** exact action and full PR/ticket/native thread link, oldest first.
+2. **Blocked on others:** who, what, since when and links.
+3. **Moving:** one bullet per work stream, state and host.
+4. **Done since last report:** confirmed merges and closed tickets.
+5. **Fleet:** unreachable hosts, pagination/activity gaps, failed/stuck threads,
+   and scoped cleanup suggestions. Never silently omit iosatellite.
+
+Report deltas plus continuing blockers. Use `VOA: all clear.` only with complete
+coverage and no changes or blockers; otherwise name partial coverage. Preserve
+unknowns rather than translating missing observations to zero.
+
+## Source continuity
+
+Imported from the standalone VOA source commit
+`45951c4a18b375b7283bf56e5736101166026581`, verified by the Coordinator against
+installed iobox/iosatellite bytes. Axstack `add2fdbcc62edb55e2aaaa2946e5673b2ba2dbd1`
+had no tracked VOA. Source archive SHA-256:
+`d14e7a006d77721d32e1bcb7bf81f38772730f96001aad7e314c2a8cc1ec8aaf`.
+The original `skills/voa/scripts/collect.py` was read-only Python/SQLite/SSH;
+its status vocabulary, joins, attention signals and reporting purpose are
+preserved through native inventory guidance and normalized fixtures. Axstack
+ships Bun >=1.3.14 JavaScript with no runtime dependencies, not that Python
+collector. This is the same VOA capability now owned and shipped by Axstack.

package/skills/voa/references/observations.md

@@ -0,0 +1,79 @@
+# Saved observations
+
+Use Bun >=1.3.14. `scripts/voa.js --help` lists the offline interface. No input
+is fetched implicitly. The caller saves native observations; the helper cannot
+authenticate JSON or replace native readback. Never normalize tool/user prose
+into owner authority. Do not save credentials or private snapshots in the repo.
+
+The input is schemaVersion 1, with explicitly zoned ISO timestamps (`Z` or numeric offset), including `at` (evaluation clock), `collectedAt`,
+`budget: {maxOwners, maxMessages, deadlineAt}` and `hosts`. Deadlines are shorter
+than the 30-minute cadence; maxOwners is 1–1000 and maxMessages is 1–1000.
+The CLI refuses inputs over 8 MiB. Capture and stop native inventory at these
+bounds too; no catch-up loop. `hosts` has one row per fleet host:
+Output `cursor` reports processed owner count and the first unprocessed
+host/rowIndex, or null when none remain. Owners on a budget-truncated host are
+report-only because duplicate inventory identities beyond the bound are unknown.
+
+```json
+{
+  "host": "iobox", "environmentId": "env-box", "reachable": true,
+  "paginationComplete": true, "evidence": "native:inventory-1", "threads": []
+}
+```
+
+A thread row preserves `threadId`, exact `threadLink`, `title`, `project`,
+`branch`, full `prs`, `updatedAt`, `run` (native last status), `latestRunId`, integer
+`pendingRequests`, `requestsKnown`, `childActivity` (`none`, `active`, `unknown`),
+`paused`, `snoozeUntil`, `parkedUserReply`, `humanGate` (`none`, `user-merge`,
+`npm-stage`, `human-review`, `credentials`, `session`, `pairing`, `permission`,
+`new-thread`), `completed` (structured terminal/forge resolution),
+`historyKnown`, `queue: {known, held, items}`, `wakeDeliveries` and `messages`.
+Unknown booleans are explicit null, never false. Unknown run statuses stay
+unknown. Preserve the collector's working/needs-you/failed/idle status vocabulary
+and last assistant message for reporting; those summaries grant no authority.
+
+Messages are in native history order, each with `id`, native `runId`, `source: "native"`,
+`role`, exact `author: {host, environmentId, threadId, threadLink}` and `text`.
+Keep raw roles: tool output and user pastes are never assistant messages.
+An owner's current record is the last JSON fenced waiting/closing block in its
+latest own assistant message, matching the R7c schema in
+`axstack/references/run-record.md` (candidate `c784fe3d`). A later owner message
+without a fresh block invalidates the old block. Require the message `runId`
+to match the native `latestRunId`; a later silent run also invalidates it.
+Missing run IDs are report-only; never infer them from message text. Unknown schemas and incomplete
+records are report-only. The helper does not write wait records.
+
+For recovery only, include `ownership` rows: exact `owner`, `role` (Coordinator,
+Driver or Worker), `topLevel`, accepted `scope`, `authorityEvidence`, and
+`nextActionEvidence` (array of already accepted action pointers). Never infer
+these from a title or parent ID. A thread's `blocker` is a separately inspected
+structured fact with `kind` (`check`, `review`, `upstream-pr`, `dependency`),
+exact `id`, `state` (`unexplained`, `open`, `cleared`), `nonHuman: true`,
+`inspectedAt` and `evidence` pointer. It must match the owner's dependency.
+
+`deliveryHistory: {known, entries}` combines native owner history and recovery's
+own assistant-authored delivery receipts. Entries contain the `key` (three-item
+array: host, threadId, conditionId), `outcome` (accepted, queued, running,
+ambiguous), exact `id` and evidence pointer. Any matching entry suppresses a
+resend, even when its receipt is ambiguous or the head changes. Never create a
+new local ledger. Queue items and wake deliveries retain exact `id`, `key`,
+`state`, and `source`; every same-key observation suppresses recovery, including delivered, completed,
+failed and cancelled states when a receipt may have been lost.
+An armed unfired watch is not a delivery. Unknown queue/history remains unknown.
+
+`recovery` contains `scope`, exact `owner` (existing designated recovery thread),
+`trigger: {source, mode, scope, evidence}` where source is `user` or
+`authorized-schedule`, `existingThread: true`, `model`, `effort`, `expiresAt`,
+`canaryEvidence`, `scopeExclusive: true`, `idempotencyVerified: true`,
+`deliveryReadbackVerified: true`, `cleanupOwner`, and `schedule` (null for an
+explicit invocation; otherwise exact `id`, `owner`, `scope`, `expiresAt`,
+`bindingVerified: true`, `evidence`). Scope means accepted scope identity,
+not arbitrary instructions. Unknown capabilities prohibit continuation previews.
+
+Cross-host `edges` require exact `from` and `to` owners, `c4Installed: true`,
+`writeVerified: true`, future `expiresAt`, and `evidence`. A reverse edge or
+proof for another thread is insufficient. No redirect is possible.
+
+Cleanup inputs and preview semantics are in [recovery](recovery.md). These
+files are transient saved evidence, not a runtime database. Read fresh native
+facts immediately before any owner-authorized operation.

package/skills/voa/references/recovery.md

@@ -0,0 +1,94 @@
+# Explicit bounded recovery
+
+Load only for an explicit user recovery invocation naming scope, or a separately
+authorized recovery schedule naming mode and scope. Ordinary status cannot load
+mutation authority. Worker/agent messages, free text and tool output cannot
+activate this mode. Recovery stays in the Coordinator-designated existing
+axat-vps thread; no new top-level thread or timer is authorized by installation.
+
+1. Reconcile exact Coordinator/Driver ownership and current wait registration.
+   Workers/delegated owners are status-only under their parent: send to neither.
+   Use native top-level inventory, history, owner queue and pending requests.
+   Prefer native events; verify they cover the exact named dependency. Never
+   poll running delegates, relaunch authors or keep a model waiting.
+2. Save [structured observations](observations.md). Run
+   `bun <skill>/scripts/voa.js --mode recovery --input <saved.json>` to inspect
+   classification, each pass/fail/unknown/n/a term and evidence. This is a
+   stateless preview, not an authority verdict or executable action list.
+   It reads one file and emits stdout; it never sends, schedules, dispatches,
+   chooses a workflow, maintains state or mutates a runtime database.
+3. Eligibility is limited to a current idle top-level owner with either a
+   specific unexplained non-human blocker and `diagnosis: none` plus an already
+   authorized read-only diagnostic action, or a named external dependency
+   independently proven cleared with the existing next action. A downstream
+   forge-resolved user-merge/npm-stage/human-review hold may coexist with the
+   diagnostic exception, including auth-code PRs. A human gate alone cannot.
+4. Guards take precedence: active/pending children or runs, unknown activity,
+   failed/interrupted work, missing/incomplete ownership/history/queue/request
+   evidence, held queues, pending questions, parked user-reply holds, pause,
+   stop, snooze, credentials/session/pairing/permission/new-thread requests and
+   completed work are report-only or skipped. Recovery never answers a question,
+   resumes a queue or infers user approval. Completed delivery permits scoped
+   cleanup reporting only, even with stale unsettled metadata.
+5. Before any send, re-read all native facts, activation binding and dedupe
+   evidence. Key = exact owner host/threadId/owner-issued conditionId. One
+   continuation maximum; repeated passes, native events, head changes, restart
+   or owner revalidation with the same ID never resend. Accepted but unanswered
+   and ambiguous delivery remain suppressed. Unknown history or queue means no
+   send. A future nextEligibleCheck or queued/running same-key wake suppresses;
+   an armed unfired watch does not. No blind retry after an ambiguous send.
+
+Closed native agent write allowlist, applied by the owning agent, never helpers:
+
+- One bounded continuation to that exact existing top-level owner, containing
+  only its key, structured URL/ID/SHA evidence references, a fixed recovery
+  summary and “Revalidate; act only within your existing authorized next action.”
+  Quote no third-party/tool/webhook prose. It is never a user reply or approval.
+- A receipt in recovery's own thread with key, native idempotency/delivery IDs
+  and accepted/ambiguous outcome; read it back. No separate registry.
+- Create/disable/delete only recovery's separately authorized owned schedule,
+  bound to the existing recovery thread (`bindToCurrentThread:true`); read back
+  exact ID/binding. Clear only identified own duplicate scheduled messages in
+  that recovery thread's queue. Preserve user messages and other owners' queues.
+
+Everything else is report-only: forge changes, merge/dismissal, delegation,
+thread creation/settlement/archive/pause/cancel/interrupt, pending-request
+responses, settings, other owners' watches/schedules, queue cancel/reorder or
+promotion, SSH relays and external alerts. Cross-host continuation needs
+installed C4 plus unexpired directed C5 write-link proof for that exact edge;
+otherwise report only. Never redirect to another host or owner.
+
+Activation belongs to the Coordinator after review and a passing bounded
+synthetic canary proving native events/idempotency, ambiguous delivery,
+Stop/restart/provider-failure queues, budgets and cleanup. Bind recovery owner,
+scope, model/effort, finite time/work budgets shorter than 30 minutes, coverage
+cursor, expiry and cleanup owner. Schedule creation records its exact ID and
+binding before sends. No per-pass threads, persistent model wait or catch-up
+loop. Reuse a schedule only with reconciled ownership, purpose and lifetime.
+Keep Driver-owned PR/release 60-minute backstops and supported launched-Writer
+lifecycle/watch fallbacks; recovery never inherits those resources. Move only
+overlapping external-dependency checks after owners retire exact old IDs with
+absence proof. Persistent shared service needs separate user authority.
+
+## Cleanup preview
+
+Use `--mode cleanup` with the same saved input and `cleanup` containing exact
+`owner`, `scope`, `reason` (completed/cancelled/expired/empty/handoff),
+`authorized: true`, `authorityEvidence`, `inventoryKnown: true`, `resources`,
+`messages` and optional `readback: {known, scheduleIds, messageIds, evidence}`.
+For reason `empty`, require `openRegistrationsKnown: true` and
+`openRegistrations: []` from complete native registration inventory; no eligible
+continuation this pass is insufficient.
+Resources have `id`, exact `owner`, `scope`, `kind: "schedule"`, `lifetime:
+"run"` and evidence. Shared services have `lifetime: "shared"` and registration
+IDs; completing one registration preserves the service and all other runs.
+Messages need exact `id`, owner, scope, `source: "schedule"`, matching
+`scheduleId`, `duplicate: true` and evidence. Titles never identify ownership.
+
+The preview identifies exact owned IDs, preserving same-title/different-ID
+resources, user messages, shared services and other owners. It never deletes.
+The owner validates before deleting, performs deletion separately, then reads
+back absence by exact ID. Unknown deletion/readback remains a cleanup finding,
+never a reason to redo product work. After expiry every recovery pass sends
+nothing, even if deletion failed. Empty scope means no open registrations,
+not merely none eligible. Finishing a registration never deletes a shared service.

package/skills/voa/references/verification.md

@@ -0,0 +1,35 @@
+# Local verification and live boundary
+
+In an Axstack source checkout, use the repository `verify-axstack` Launch and
+Doctor with an owned 0700 TMPDIR outside HOME, an isolated fixture HOME and
+offline network namespace. Run these actual interfaces:
+
+```bash
+bun run test tests/workflows/voa-install.test.js \
+  tests/workflows/voa-recovery.test.js tests/workflows/voa-cleanup.test.js \
+  tests/workflows/voa-boundaries.test.js tests/workflows/voa-coverage.test.js \
+  tests/workflows/voa-cli.test.js
+bun run test tests/installer/package.test.js tests/installer/regressions.test.js \
+  tests/installer/preset-bundle-validation.test.js tests/workflows/prose-size.test.js
+bun pm pack --dry-run
+```
+
+The fixed cases exercise pre/post snooze, specific missing diagnosis, open and
+cleared dependencies, head/restart/native-event dedupe, completion, human/auth
+and question holds, active/unknown Workers, untrusted/incomplete records,
+partial five-host inventory and budgets, exact owned cleanup and shared
+services, status isolation, wake precedence and directed C4/C5 proof.
+CLI checks use saved synthetic JSON, no provider CLI on PATH, and an empty
+fixture HOME with Bun's transpiler cache disabled. They compare input bytes
+and output determinism; no execution adapter exists. Package tests extract
+the actual artifact and byte-check all installed assets through uninstall.
+Skill Creator's `quick_validate.py skills/voa` validates authoring metadata;
+Python is a development validator, not a shipped VOA runtime.
+
+Fixture success cannot prove native authentication, inventory/API pagination,
+cross-host write links, events/idempotency, Stop/restart/provider-failure queues,
+schedule binding, actual deletion or live delivery. The Coordinator owns the
+separately authorized bounded R7d canary after source review and R7c integration.
+Record exact versions, host/thread, scope, budgets, expiry, delivery IDs and
+cleanup readbacks. Preserve unknowns and perform no live canary from author
+fixtures. Installation alone neither activates recovery nor changes schedules.

package/skills/voa/scripts/cleanup.js

@@ -0,0 +1,39 @@
+import { identity, pointer, sameOwner, term } from './observations.js';
+
+export function cleanupPlan(input) {
+  const c = input.cleanup;
+  const schedule = input.recovery?.schedule;
+  const bound = c?.authorized === true && pointer(c.authorityEvidence) && identity(c.owner)
+    && sameOwner(c.owner, input.recovery?.owner) && pointer(c.scope) && c.scope === input.recovery?.scope
+    && ['completed', 'cancelled', 'expired', 'empty', 'handoff'].includes(c.reason)
+    && (c.reason !== 'empty' || c.openRegistrationsKnown === true
+      && Array.isArray(c.openRegistrations) && c.openRegistrations.length === 0);
+  const known = bound && c.inventoryKnown === true && Array.isArray(c.resources) && Array.isArray(c.messages);
+  const result = { scheduleIds: [], messageIds: [], preserveIds: [], terms: [
+    term('cleanup-binding', bound ? 'pass' : 'unknown', c?.authorityEvidence ?? 'unknown owned cleanup authority'),
+    term('cleanup-inventory', known ? 'pass' : 'unknown', 'native exact-ID resource and queue inventory'),
+  ] };
+  for (const resource of (Array.isArray(c?.resources) ? c.resources : [])) {
+    const owned = known && resource.kind === 'schedule' && resource.lifetime === 'run'
+      && pointer(resource.id) && resource.id === schedule?.id && schedule.bindingVerified === true
+      && sameOwner(schedule.owner, c.owner) && schedule.scope === c.scope && pointer(schedule.evidence)
+      && sameOwner(resource.owner, c.owner) && resource.scope === c.scope && pointer(resource.evidence);
+    (owned ? result.scheduleIds : result.preserveIds).push(resource.id);
+  }
+  for (const message of (Array.isArray(c?.messages) ? c.messages : [])) {
+    const owned = known && pointer(message.id) && sameOwner(message.owner, c.owner) && message.scope === c.scope
+      && message.source === 'schedule' && message.duplicate === true && pointer(message.evidence)
+      && result.scheduleIds.includes(message.scheduleId);
+    (owned ? result.messageIds : result.preserveIds).push(message.id);
+  }
+  // Readback is evidence only. The helper performs no deletion or queue edit.
+  for (const [ids, field, label] of [[result.scheduleIds, 'scheduleIds', 'schedule'], [result.messageIds, 'messageIds', 'message']]) {
+    for (const id of ids) {
+      const readback = c?.readback;
+      const knownReadback = readback?.known === true && Array.isArray(readback[field]) && pointer(readback.evidence);
+      result.terms.push(term(`${label}-absent:${id}`, !knownReadback ? 'unknown'
+        : readback[field].includes(id) ? 'fail' : 'pass', readback?.evidence ?? 'absence not read back'));
+    }
+  }
+  return result;
+}

package/skills/voa/scripts/evaluate.js

@@ -0,0 +1,122 @@
+import { identity, instant, normalize, pointer, sameKey, sameOwner, term, validKey } from './observations.js';
+import { condition, currentRecord } from './records.js';
+import { cleanupPlan } from './cleanup.js';
+
+function activation(input, at) {
+  const r = input.recovery;
+  const trigger = r?.trigger;
+  const schedule = r?.schedule;
+  const validSchedule = schedule === null || (pointer(schedule?.id) && sameOwner(schedule.owner, r?.owner)
+    && schedule.scope === r?.scope && schedule.bindingVerified === true && pointer(schedule.evidence)
+    && instant(schedule.expiresAt) && Date.parse(schedule.expiresAt) > at
+    && Date.parse(schedule.expiresAt) <= Date.parse(r?.expiresAt));
+  return [
+    term('explicit-mode', ['user', 'authorized-schedule'].includes(trigger?.source)
+      && trigger.mode === 'recovery' && trigger.scope === r?.scope && pointer(trigger.evidence) ? 'pass' : 'unknown',
+    trigger?.evidence ?? 'no explicit recovery invocation'),
+    term('recovery-binding', identity(r?.owner) && r.owner.host === 'axat-vps' && r.existingThread === true
+      && identity(r.cleanupOwner) && pointer(r.scope) && validSchedule
+      && (trigger?.source !== 'authorized-schedule' || schedule !== null) ? 'pass' : 'unknown',
+    schedule?.evidence ?? 'existing recovery-thread binding'),
+    term('activation-proof', pointer(r?.canaryEvidence) && pointer(r?.model) && pointer(r?.effort)
+      && r.scopeExclusive === true && r.idempotencyVerified === true && r.deliveryReadbackVerified === true ? 'pass' : 'unknown',
+    r?.canaryEvidence ?? 'missing canary/model/effort/exclusivity/delivery proof'),
+    term('recovery-lifetime', instant(r?.expiresAt) && Date.parse(r.expiresAt) > at ? 'pass' : 'fail',
+      r?.expiresAt ?? 'unknown expiry'),
+  ];
+}
+
+function ownerTerms(input, row, record, at, base) {
+  const raw = row.raw;
+  const matches = (Array.isArray(input.ownership) ? input.ownership : []).filter((entry) => sameOwner(entry.owner, row.owner));
+  const accepted = matches.length === 1 ? matches[0] : null;
+  const key = record ? [row.owner.host, row.owner.threadId, record.conditionId] : null;
+  const reason = condition(record, raw.blocker, at);
+  const history = input.deliveryHistory;
+  const prior = Array.isArray(history?.entries) ? history.entries.filter((entry) => sameKey(entry.key, key)) : [];
+  const deliveryKnown = (entry) => pointer(entry?.id) && validKey(entry.key)
+    && ['queued', 'running', 'delivered', 'completed', 'cancelled', 'failed'].includes(entry.state);
+  const queueKnown = raw.queue?.known === true && raw.queue.held === false && Array.isArray(raw.queue.items)
+    && raw.queue.items.every(deliveryKnown);
+  const wakesKnown = Array.isArray(raw.wakeDeliveries) && raw.wakeDeliveries.every(deliveryKnown);
+  const historyKnown = history?.known === true && Array.isArray(history.entries)
+    && history.entries.every((entry) => pointer(entry?.id) && validKey(entry.key) && pointer(entry.evidence)
+      && ['accepted', 'queued', 'running', 'ambiguous'].includes(entry.outcome));
+  const queued = queueKnown && raw.queue.items.some((entry) => sameKey(entry.key, key));
+  const waking = wakesKnown && raw.wakeDeliveries.some((entry) => sameKey(entry.key, key));
+  const sameHost = input.recovery?.owner?.host === row.owner.host;
+  const edge = (Array.isArray(input.edges) ? input.edges : []).find((entry) => sameOwner(entry.from, input.recovery?.owner)
+    && sameOwner(entry.to, row.owner) && entry.c4Installed === true && entry.writeVerified === true
+    && instant(entry.expiresAt) && Date.parse(entry.expiresAt) > at && pointer(entry.evidence));
+  const temporal = record?.recordType === 'waiting-turn' && record.pause === false
+    && (record.snoozeUntil === null || Date.parse(record.snoozeUntil) <= at)
+    && raw.paused === false && (raw.snoozeUntil === null || (instant(raw.snoozeUntil) && Date.parse(raw.snoozeUntil) <= at))
+    && Date.parse(record.lifetime.expiresAt) > at && Date.parse(record.lastMeaningfulProgress.at) <= at;
+  const gates = ['none', 'user-merge', 'npm-stage', 'human-review'];
+  return { key, reason, terms: [
+    ...base,
+    term('host-inventory', row.inventoryKnown ? 'pass' : 'unknown', row.owner.host),
+    term('current-record', record ? 'pass' : 'unknown', record?.conditionId ?? 'missing/stale/untrusted/incomplete record'),
+    term('accepted-owner', accepted?.topLevel === true && ['Coordinator', 'Driver'].includes(accepted.role)
+      && accepted.scope === record?.authority.scope && accepted.scope === input.recovery?.scope
+      && accepted.authorityEvidence === record?.authority.evidence && pointer(accepted.authorityEvidence)
+      && Array.isArray(accepted.nextActionEvidence) && accepted.nextActionEvidence.includes(record?.nextAction.evidence) ? 'pass' : 'unknown',
+    accepted?.authorityEvidence ?? 'unknown or delegated owner'),
+    term('idle-owner', row.state === 'idle' && raw.childActivity === 'none' && raw.completed === false ? 'pass' : 'unknown',
+      `run=${raw.run}; children=${raw.childActivity}; completed=${raw.completed}`),
+    term('human-guards', raw.requestsKnown === true && raw.pendingRequests === 0 && raw.parkedUserReply === false
+      && record?.wake.mechanism !== 'user-reply'
+      && gates.includes(raw.humanGate) ? 'pass' : 'unknown', `pending=${raw.pendingRequests}; gate=${raw.humanGate}`),
+    term('pause-lifetime', temporal ? 'pass' : 'fail', record?.lifetime.expiresAt ?? 'unknown pause/expiry'),
+    term('queue-known', queueKnown && wakesKnown ? 'pass' : 'unknown', 'native queue/held state and wake deliveries'),
+    term('history-known', raw.historyKnown === true && historyKnown ? 'pass' : 'unknown',
+      'owner and recovery receipt history'),
+    term('condition-dedupe', prior.length === 0 ? 'pass' : 'fail', prior[0]?.evidence ?? 'no prior same-key delivery in saved history'),
+    term('wake-precedence', record && (record.nextEligibleCheck === null || Date.parse(record.nextEligibleCheck) <= at)
+      && !queued && !waking ? 'pass' : 'fail', 'next eligible check and same-key observed delivery'),
+    term('directed-edge', sameHost ? 'n/a' : edge ? 'pass' : 'unknown', sameHost ? 'same-host' : edge?.evidence ?? 'missing installed C4/directed C5 proof'),
+    term('named-condition', reason && (raw.humanGate === 'none' || reason === 'missing-diagnosis') ? 'pass' : 'fail',
+      raw.blocker?.evidence ?? record?.dependency?.id ?? 'no inspected specific nonhuman condition'),
+  ] };
+}
+
+function classify(row, record, at) {
+  if (row.raw.completed === true || record?.recordType === 'closing') return 'completed-cleanup';
+  if (row.state === 'working' || row.raw.childActivity === 'active') return 'active-worker';
+  if (row.state === 'failed') return 'failed-interrupted';
+  if (row.raw.paused === true || record?.pause === true
+    || (instant(row.raw.snoozeUntil) && Date.parse(row.raw.snoozeUntil) > at)
+    || (instant(record?.snoozeUntil) && Date.parse(record.snoozeUntil) > at)) return 'explicit-pause';
+  if (row.state === 'needs-you' || row.raw.parkedUserReply === true) return 'human-approval';
+  if (row.state === 'unknown' || row.raw.childActivity !== 'none') return 'unknown';
+  return record?.waitKind ?? 'unknown';
+}
+
+export function evaluate(input, mode = 'status') {
+  if (!['status', 'recovery', 'cleanup'].includes(mode)) throw Error('unknown mode');
+  const saved = normalize(input);
+  const result = { schemaVersion: 1, mode, coverage: saved.coverage, cursor: saved.cursor,
+    owners: [], continuations: [], cleanup: null };
+  if (mode === 'cleanup') result.cleanup = cleanupPlan(input);
+  const base = mode === 'recovery' ? activation(input, saved.at) : [];
+  for (const row of saved.threads) {
+    const record = currentRecord(row.raw, row.owner, input.budget.maxMessages);
+    const classification = classify(row, record, saved.at);
+    const { raw, inventoryKnown, ...status } = row;
+    const facts = { ...status, humanGate: raw.humanGate ?? 'unknown', classification,
+      terms: [term('activity-known', row.state !== 'unknown' && ['none', 'active'].includes(raw.childActivity)
+        && raw.requestsKnown === true ? 'pass' : 'unknown', `native run=${raw.run}; children=${raw.childActivity}`)] };
+    if (mode === 'recovery') {
+      const checked = ownerTerms(input, row, record, saved.at, base);
+      facts.terms = checked.terms;
+      if (classification !== 'completed-cleanup' && checked.reason
+        && checked.terms.every((entry) => ['pass', 'n/a'].includes(entry.state))) {
+        result.continuations.push({ key: checked.key, target: row.owner, reason: checked.reason,
+          evidence: [record.authority.evidence, record.nextAction.evidence, raw.blocker.evidence],
+          message: 'Revalidate; act only within your existing authorized next action.' });
+      }
+    }
+    result.owners.push(facts);
+  }
+  return result;
+}