@superjackfruitlabs/salaam 0.0.3 → 0.0.5

package/dist/src/task-budget.js

@@ -6,6 +6,12 @@ export class TaskBudgetError extends ServiceError {
         this.session_id = session_id;
     }
 }
+/** Tools a critic review child may hold and still be left out of the verification busy check. */
+export const READ_ONLY_REVIEW_TOOLS = [
+    'salaam_findings',
+    'salaam_probe',
+    'salaam_repository',
+];
 export class TaskBudget {
     store;
     tasks;
@@ -23,6 +29,8 @@ export class TaskBudget {
         store.taskChildFinished = (attempt) => this.releaseChild(attempt);
         store.taskCommandAdmission = (session) => this.command(session);
         store.taskRemainingRuntime = (session) => this.remaining(session);
+        // Only the task's own session: a child's attempt keeps the budget its reservation set.
+        store.taskAttemptRequestLimit = (session) => this.tasks.forSession(session)?.limits.requests;
     }
     task(session) {
         const direct = this.tasks.forSession(session);
@@ -39,14 +47,42 @@ export class TaskBudget {
             .n);
         return { ...runtime, invocations_spent: n, external_model_usage: n ? 'unknown' : 'none' };
     }
-    active(task) {
+    /** The child attempt of each running critic review of this task revision whose recorded
+     * tools are all read-only (operator ruling 2026-10-30, option A). Only verification reads may
+     * leave these out of the busy count: the reviewer reads a digest-bound snapshot and cannot
+     * write the workspace, run a command or reach the station (staging card_019a647a169744ff). */
+    readOnlyReviews(task) {
+        if (!this.store.db
+            .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='task_critics'")
+            .get())
+            return [];
+        const rows = this.store.db
+            .prepare("SELECT c.child_attempt, c.authority FROM task_critics r JOIN child_tasks c ON c.id=r.child_id WHERE r.task_id=? AND r.plan_revision=? AND r.state='running' AND c.parent_session=?")
+            .all(task.id, task.plan_revision, task.session_id);
+        return rows
+            .filter((r) => {
+            try {
+                const tools = JSON.parse(r.authority);
+                return (Array.isArray(tools) &&
+                    tools.every((t) => READ_ONLY_REVIEW_TOOLS.includes(t)));
+            }
+            catch {
+                return false;
+            }
+        })
+            .map((r) => r.child_attempt);
+    }
+    /** Live work in the task's session tree. `verification` leaves out a running read-only review's
+     * child attempt, for verification reads only; admission and concurrency count everything. */
+    active(task, opts = {}) {
+        const excluded = JSON.stringify(opts.verification ? this.readOnlyReviews(task) : []);
         const row = this.store.db
             .prepare(`WITH tree(id) AS (SELECT ? UNION ALL SELECT child_session FROM child_tasks WHERE parent_session=?) SELECT
-      (SELECT count(*) FROM attempts WHERE session_id IN (SELECT id FROM tree) AND state IN ('accepted','dispatching','running')) +
+      (SELECT count(*) FROM attempts WHERE session_id IN (SELECT id FROM tree) AND state IN ('accepted','dispatching','running') AND id NOT IN (SELECT value FROM json_each(?))) +
       (SELECT count(*) FROM station_calls WHERE session_id IN (SELECT id FROM tree) AND kind='check' AND attempt_id IS NULL AND state IN ('prepared','dispatching')) +
       (SELECT count(*) FROM command_runs WHERE session_id IN (SELECT id FROM tree) AND state NOT IN ('succeeded','failed','cancelled','timed_out','output_limited','interrupted')) +
       (SELECT count(*) FROM external_runs e JOIN child_tasks c ON c.id=e.child_id JOIN attempts a ON a.id=c.child_attempt WHERE c.parent_session=? AND e.stopped=0 AND a.state NOT IN ('accepted','dispatching','running')) AS n`)
-            .get(task.session_id, task.session_id, task.session_id);
+            .get(task.session_id, task.session_id, excluded, task.session_id);
         return Number(row.n);
     }
     deny(session, message) {

package/dist/src/task-context.js

@@ -14,6 +14,10 @@ export class TaskContext {
     artifacts;
     work;
     admitted;
+    /** Interactive sessions only: AGENTS.md guidance loaded automatically (project-instructions.ts). */
+    instructions;
+    /** Interactive sessions only: a folder checkpoint before every turn (turn-rewind.ts). */
+    checkpoints;
     constructor(store, artifacts) {
         this.store = store;
         this.artifacts = artifacts;
@@ -65,11 +69,13 @@ export class TaskContext {
         if (Buffer.byteLength(frame) > TASK_FRAME_BYTES)
             throw new ServiceError('context_capacity', 'Mandatory task state exceeds the context budget');
         const admittedContext = this.admitted?.frame(id);
-        return admittedContext
+        const projectInstructions = this.instructions?.frame(id);
+        return admittedContext || projectInstructions
             ? 'SALAAM_TASK_STATE ' +
                 canonical({
                     ...JSON.parse(frame.slice('SALAAM_TASK_STATE '.length)),
-                    admitted_context: admittedContext,
+                    ...(admittedContext ? { admitted_context: admittedContext } : {}),
+                    ...(projectInstructions ? { project_instructions: projectInstructions } : {}),
                 })
             : frame;
     }

package/dist/src/task-critic.js

@@ -0,0 +1,115 @@
+import { randomUUID } from 'node:crypto';
+/**
+ * The completion critic (item 8). When the admitted plan declares a critic, the built-in reviewer
+ * reads an immutable snapshot of the verified deliverables against the plan's rubric before the
+ * task may complete. Its verdict is bound to the exact verified evidence (checks and tree): any
+ * later change makes it stale. A critical or high finding means changes are needed; a reviewer
+ * that reports nothing at all is a failure, never a pass.
+ */
+export const CRITIC_BUDGET = 4;
+export const CRITIC_REOPENS = 2;
+export class TaskCritic {
+    store;
+    artifacts;
+    deps;
+    constructor(store, artifacts, deps) {
+        this.store = store;
+        this.artifacts = artifacts;
+        this.deps = deps;
+        store.db.exec(`CREATE TABLE IF NOT EXISTS task_critics(
+      id TEXT PRIMARY KEY NOT NULL,
+      task_id TEXT NOT NULL,
+      plan_revision INTEGER NOT NULL,
+      evidence_digest TEXT NOT NULL,
+      round INTEGER NOT NULL,
+      child_id TEXT NOT NULL,
+      state TEXT NOT NULL,
+      findings TEXT,
+      reason TEXT,
+      UNIQUE(task_id, plan_revision, evidence_digest))`);
+    }
+    /** Whether this exact verified evidence has a passing critic verdict. */
+    passed(task, evidenceDigest) {
+        return (this.store.db
+            .prepare("SELECT 1 FROM task_critics WHERE task_id=? AND plan_revision=? AND evidence_digest=? AND state='pass'")
+            .get(task.id, task.plan_revision, evidenceDigest) !== undefined);
+    }
+    /** How many times the critic has sent this plan revision back for changes. */
+    reopens(task) {
+        return Number(this.store.db
+            .prepare("SELECT count(*) AS n FROM task_critics WHERE task_id=? AND plan_revision=? AND state='changes_needed'")
+            .get(task.id, task.plan_revision).n);
+    }
+    /** The verdict for this verified evidence, starting the reviewer the first time it is asked. */
+    async gate(task, evidenceDigest, deliverables) {
+        const critic = task.completion_gate?.critic;
+        if (!critic)
+            return { state: 'pass' };
+        const row = this.store.db
+            .prepare('SELECT * FROM task_critics WHERE task_id=? AND plan_revision=? AND evidence_digest=?')
+            .get(task.id, task.plan_revision, evidenceDigest);
+        if (row)
+            return this.settle(row);
+        const last = this.store.db
+            .prepare('SELECT b.attempt_id FROM task_step_attempts b JOIN task_steps s ON s.id=b.step_id WHERE s.task_id=? ORDER BY b.rowid DESC LIMIT 1')
+            .get(task.id);
+        if (!last)
+            return { state: 'failed', reason: 'No step attempt for the critic to follow' };
+        if (!deliverables.length)
+            return { state: 'failed', reason: 'No verified deliverables to review' };
+        const round = Number(this.store.db
+            .prepare('SELECT count(*) AS n FROM task_critics WHERE task_id=? AND plan_revision=?')
+            .get(task.id, task.plan_revision).n) + 1;
+        const snapshot = Object.fromEntries(deliverables.map((d) => [
+            d.path,
+            { content: Buffer.from(d.content, 'utf8').toString('base64'), executable: false },
+        ]));
+        const grant = await this.deps.admit(task, `critic:${task.id}:${task.plan_revision}`);
+        const child = this.deps.spawn(task, String(last.attempt_id), `critic-${task.plan_revision}-${round}`, [
+            'Judge the delivered work against this rubric before it is accepted:',
+            critic.rubric,
+            '',
+            'Objective: ' + task.objective,
+            'Deliverables (the snapshot): ' + deliverables.map((d) => d.path).join(', '),
+            '',
+            'Report findings with salaam_findings, citing the file and line. Use critical or high only',
+            'for what must change before the work is accepted; medium or low for suggestions. If the',
+            'work meets the rubric, report an empty list.',
+        ].join('\n'), CRITIC_BUDGET, grant, snapshot);
+        this.store.db
+            .prepare("INSERT INTO task_critics VALUES (?,?,?,?,?,?,'running',NULL,NULL)")
+            .run(randomUUID(), task.id, task.plan_revision, evidenceDigest, round, child.id);
+        return { state: 'pending' };
+    }
+    settle(row) {
+        if (row.state === 'pass')
+            return { state: 'pass' };
+        if (row.state === 'changes_needed')
+            return { state: 'changes_needed', findings: JSON.parse(String(row.findings)) };
+        if (row.state === 'failed')
+            return { state: 'failed', reason: String(row.reason) };
+        const child = this.store.db
+            .prepare('SELECT state FROM child_tasks WHERE id=?')
+            .get(String(row.child_id));
+        if (!child || child.state === 'accepted')
+            return { state: 'pending' };
+        const report = this.store.db
+            .prepare('SELECT artifact_id FROM specialist_reports WHERE worker_id=?')
+            .get(this.deps.workerId(String(row.child_id)));
+        const set = (state, findings, reason) => this.store.db
+            .prepare('UPDATE task_critics SET state=?,findings=?,reason=? WHERE id=?')
+            .run(state, findings ? JSON.stringify(findings) : null, reason, String(row.id));
+        if (!report) {
+            const reason = 'The critic returned no findings report';
+            set('failed', null, reason);
+            return { state: 'failed', reason };
+        }
+        const findings = JSON.parse(this.artifacts.read(String(report.artifact_id))).findings.map(({ path, line, severity, message }) => ({ path, line, severity, message }));
+        if (findings.some((f) => f.severity === 'critical' || f.severity === 'high')) {
+            set('changes_needed', findings, null);
+            return { state: 'changes_needed', findings };
+        }
+        set('pass', findings, null);
+        return { state: 'pass' };
+    }
+}

package/dist/src/task-driver.js

@@ -1,3 +1,6 @@
+import { CRITIC_REOPENS } from './task-critic.js';
+import { requiredChecks } from './task-policy.js';
+import { RATE_LIMIT_STOP, RateLimitRetries } from './rate-limit-retries.js';
 import { randomUUID } from 'node:crypto';
 import { commandTerminal } from './coding.js';
 import { canonical, ServiceError } from './protocol.js';
@@ -14,6 +17,7 @@ export class TaskDriver {
     awaitingAuthorityRenewal;
     active;
     stopped = true;
+    rateLimits;
     constructor(store, tasks, budget, verification, supervisor, children, coding) {
         this.store = store;
         this.tasks = tasks;
@@ -22,6 +26,7 @@ export class TaskDriver {
         this.supervisor = supervisor;
         this.children = children;
         this.coding = coding;
+        this.rateLimits = new RateLimitRetries(store);
         tasks.assertProgressionBinding = (task, binding) => {
             if (canonical(this.verification.binding(task)) !== binding)
                 throw new ServiceError('task_progression_stale', 'Workspace or execution environment changed since the bounded grant');
@@ -295,6 +300,22 @@ export class TaskDriver {
             return;
         }
         if (task.steps.some((s) => ['interrupted', 'failed', 'cancelled'].includes(s.state))) {
+            // A provider 429 is retried as a fresh attempt of the step after a backoff; past the limit,
+            // or with no progression step left, the task stops with a block recovery can settle.
+            const retry = this.rateLimits.decide(task);
+            if (retry.action === 'wait')
+                return;
+            if (retry.action === 'retry' && Number(r.remaining_steps) >= 1) {
+                if (!(await this.worker(task)) || this.stopped)
+                    return;
+                this.tasks.retryStep(task.id, retry.step, retry.n, Number(r.auto_epoch));
+                return;
+            }
+            if (retry.action !== 'none') {
+                this.budget.block(task.session_id, RATE_LIMIT_STOP);
+                this.stop(task, RATE_LIMIT_STOP);
+                return;
+            }
             this.stop(task, 'An interrupted or failed step requires explicit operator review');
             return;
         }
@@ -334,14 +355,37 @@ export class TaskDriver {
             // A passed receipt cannot be re-observed while another final check owns
             // the native workspace. Wait for the whole set before testing freshness;
             // finishAsync still performs the final transactional evidence validation.
-            if (task.acceptance.some((check) => {
+            if (requiredChecks(task).some((check) => {
                 const receipt = this.verification.latest(task, check.key, null);
                 return receipt?.state === 'accepted' || receipt?.state === 'running';
             }))
                 return;
-            for (const check of task.acceptance)
+            for (const check of requiredChecks(task))
                 if (!(await this.check(task, check.key, null)))
                     return;
+            // Item 8: a declared critic reviews the verified deliverables before completion.
+            if (task.completion_gate?.critic) {
+                const verdict = await this.verification.criticGateAsync(task);
+                if (verdict.state === 'pending')
+                    return;
+                if (verdict.state === 'failed') {
+                    this.stop(task, 'Critic review failed: ' + verdict.reason);
+                    return;
+                }
+                if (verdict.state === 'changes_needed') {
+                    const round = this.verification.critic.reopens(task);
+                    if (round > CRITIC_REOPENS || Number(r.remaining_steps) < 1) {
+                        this.stop(task, 'Critic requested changes');
+                        return;
+                    }
+                    if (!(await this.worker(task)) || this.stopped)
+                        return;
+                    this.tasks.reopenForCritic(task.id, task.steps.at(-1).id, round, Number(r.auto_epoch), verdict.findings
+                        .map((f) => `- ${f.path}:${f.line} (${f.severity}) ${f.message}`)
+                        .join('\n'));
+                    return;
+                }
+            }
             await this.verification.finishAsync(task.id, 'auto-finish:' + task.id + ':' + task.plan_revision, task.revision, null, () => {
                 if (!this.budget.state(task.id).auto_enabled)
                     throw new ServiceError('task_authority', 'Progression paused before completion');

package/dist/src/task-policy.js

@@ -1,5 +1,23 @@
 import { integer, object, ServiceError, string } from './protocol.js';
 import { filePath } from './workspaces.js';
+/** Every check completion requires: the acceptance checks, then each hook as hook-<key>. */
+export function requiredChecks(policy) {
+    return [
+        ...policy.acceptance,
+        ...(policy.completion_gate?.hooks ?? []).map((h) => ({ ...h, key: 'hook-' + h.key })),
+    ];
+}
+const check = (v, keys, what) => {
+    const c = object(v), key = string(c.key, what + ' key', 64);
+    if (!/^[a-zA-Z0-9_-]+$/.test(key) || keys.has(key))
+        throw new ServiceError('invalid_plan', what + ' keys must be unique identifiers', 400);
+    keys.add(key);
+    return {
+        key,
+        command: string(c.command, what + ' command', 4096),
+        cwd: c.cwd === undefined || c.cwd === '.' ? '.' : filePath(c.cwd),
+    };
+};
 export const DEFAULT_TASK_LIMITS = {
     requests: 64,
     runtime_ms: 900000,
@@ -14,17 +32,7 @@ export function taskPolicy(value) {
     if (!Array.isArray(raw) || raw.length > 8)
         throw new ServiceError('invalid_plan', 'Supply at most eight acceptance checks', 400);
     const keys = new Set();
-    const acceptance = raw.map((v) => {
-        const c = object(v), key = string(c.key, 'check key', 64);
-        if (!/^[a-zA-Z0-9_-]+$/.test(key) || keys.has(key))
-            throw new ServiceError('invalid_plan', 'Acceptance keys must be unique identifiers', 400);
-        keys.add(key);
-        return {
-            key,
-            command: string(c.command, 'check command', 4096),
-            cwd: c.cwd === undefined || c.cwd === '.' ? '.' : filePath(c.cwd),
-        };
-    });
+    const acceptance = raw.map((v) => check(v, keys, 'Acceptance'));
     const paths = value.deliverables ?? [];
     if (!Array.isArray(paths) || paths.length > 32)
         throw new ServiceError('invalid_plan', 'Supply at most 32 deliverable paths', 400);
@@ -66,5 +74,29 @@ export function taskPolicy(value) {
             throw new ServiceError('invalid_budget', 'Invocation limit must be 1–64', 400);
         limits.invocations = n;
     }
-    return { acceptance, deliverables, limits };
+    let completion_gate;
+    if (value.completion_gate !== undefined) {
+        const g = object(value.completion_gate);
+        const hooks = g.hooks;
+        const c = g.critic;
+        const critic = c === null
+            ? null
+            : (() => {
+                const v = object(c);
+                if (Object.keys(v).join(',') !== 'rubric')
+                    throw new ServiceError('invalid_plan', 'A critic names only its rubric', 400);
+                return { rubric: string(v.rubric, 'critic rubric', 4096) };
+            })();
+        if (Object.keys(g).sort().join(',') !== 'critic,hooks' ||
+            !Array.isArray(hooks) ||
+            hooks.length > 8 ||
+            (!critic && hooks.length < 1))
+            throw new ServiceError('invalid_plan', 'A completion gate has a critic or 1–8 hooks, and at most 8 hooks', 400);
+        const hookKeys = new Set();
+        completion_gate = { critic, hooks: hooks.map((v) => check(v, hookKeys, 'Hook')) };
+        if (requiredChecks({ acceptance, completion_gate }).length !==
+            new Set(requiredChecks({ acceptance, completion_gate }).map((c) => c.key)).size)
+            throw new ServiceError('invalid_plan', 'A hook collides with an acceptance check', 400);
+    }
+    return { acceptance, deliverables, limits, ...(completion_gate ? { completion_gate } : {}) };
 }

package/dist/src/task-verification.js

@@ -1,3 +1,4 @@
+import { requiredChecks } from './task-policy.js';
 import { StationTaskVerification } from './station-task-verification.js';
 import { randomUUID } from 'node:crypto';
 import { commandTerminal } from './coding.js';
@@ -39,7 +40,7 @@ export class TaskVerification {
         };
     }
     assertIdle(task, stationInspection) {
-        if (this.budget.active(task) > 0 ||
+        if (this.budget.active(task, { verification: true }) > 0 ||
             this.store.db
                 .prepare("SELECT 1 FROM compactions WHERE session_id=? AND state='running'")
                 .get(task.session_id))
@@ -105,7 +106,7 @@ export class TaskVerification {
             this.assertIdle(task);
             if (!this.station)
                 this.coding.assertSafe(task.session_id);
-            if (!task.acceptance.some((c) => c.key === key))
+            if (!requiredChecks(task).some((c) => c.key === key))
                 throw new ServiceError('invalid_check', 'Check is not in this task plan');
             if (step &&
                 !task.steps.some((s) => s.id === step && s.state === 'awaiting_review' && s.checks?.includes(key)))
@@ -147,7 +148,7 @@ export class TaskVerification {
             this.station.dispatch(id);
             return;
         }
-        const task = this.tasks.get(receipt.task_id), check = task.acceptance.find((c) => c.key === receipt.check_key);
+        const task = this.tasks.get(receipt.task_id), check = requiredChecks(task).find((c) => c.key === receipt.check_key);
         try {
             const existing = this.store.db
                 .prepare('SELECT id FROM command_runs WHERE session_id=? AND step_key=?')
@@ -383,6 +384,26 @@ export class TaskVerification {
             throw new ServiceError('verification_required', 'Protected station completion requires awaited verification');
         return this.finishRecorded(id, request, expected, exception, authorize);
     }
+    /** Item 8: the completion critic, when the service has one. */
+    critic;
+    /** The critic's verdict on the current fresh verified evidence, starting it the first time.
+     * Reads the evidence outside the finishing transaction, so starting the reviewer can never be
+     * rolled back with a refused finish; the finish itself re-checks the verdict against its own
+     * evidence. */
+    async criticGateAsync(task) {
+        if (!task.completion_gate?.critic)
+            return { state: 'pass' };
+        if (!this.critic || !this.station)
+            return { state: 'failed', reason: 'A critic needs the station verification boundary' };
+        const checks = requiredChecks(task).map((c) => this.latest(task, c.key, null));
+        if (checks.some((c) => !c || c.state !== 'passed'))
+            return { state: 'pending' };
+        const fresh = await this.station.withFreshMany(checks.map((c) => c.id), task.deliverables, (evidence, deliverables) => ({ evidence, deliverables }));
+        return this.critic.gate(task, digest(fresh.evidence), fresh.deliverables.map(({ path, content }) => ({
+            path,
+            content,
+        })));
+    }
     async finishAsync(id, request, expected, exception, authorize) {
         if (!this.station)
             return this.finish(id, request, expected, exception, authorize);
@@ -401,7 +422,7 @@ export class TaskVerification {
             throw new ServiceError('verification_required', 'Strict station work requires verified completion without exceptions');
         if (!task.acceptance.length || !task.deliverables.length)
             throw new ServiceError('verification_required', 'Configured checks and deliverables required');
-        const checks = task.acceptance.map((c) => this.latest(task, c.key, null));
+        const checks = requiredChecks(task).map((c) => this.latest(task, c.key, null));
         if (checks.some((c) => !c || c.state !== 'passed'))
             throw new ServiceError('verification_required', 'Passed configured checks required');
         return this.station.withFreshMany(checks.map((c) => c.id), task.deliverables, (evidence, deliverables) => this.finishRecorded(id, request, expected, null, authorize, { evidence, deliverables }));
@@ -415,7 +436,7 @@ export class TaskVerification {
         if (view.completion?.state === 'succeeded') {
             try {
                 const evidence = JSON.parse(this.artifacts.read(String(view.completion.artifact_id)));
-                const checks = task.acceptance.map((c) => this.latest(task, c.key, null));
+                const checks = requiredChecks(task).map((c) => this.latest(task, c.key, null));
                 if (checks.some((c) => !c || c.state !== 'passed' || !evidence.checks.includes(c.id)))
                     throw Error('Changed checks');
                 view.completion.fresh = await this.station.withFreshMany(checks.map((c) => c.id), task.deliverables, (fresh) => view.completion.plan_revision === this.tasks.get(task.id).plan_revision &&
@@ -441,7 +462,7 @@ export class TaskVerification {
             this.assertIdle(task);
             if (task.steps.some((s) => s.state !== 'completed'))
                 throw new ServiceError('verification_required', 'Every step must be reviewed or verified');
-            const checks = task.acceptance.map((c) => this.latest(task, c.key, null));
+            const checks = requiredChecks(task).map((c) => this.latest(task, c.key, null));
             const missing = [];
             if (!task.acceptance.length)
                 missing.push('No configured acceptance checks');
@@ -452,13 +473,21 @@ export class TaskVerification {
                     (protectedResult
                         ? !protectedResult.evidence.some((e) => e.check_id === checks[n].id)
                         : !this.fresh(checks[n])))
-                    missing.push('Fresh check required: ' + task.acceptance[n].key);
+                    missing.push('Fresh check required: ' + requiredChecks(task)[n].key);
             let workspace = null, deliverables = [], diff = null;
             try {
                 if (protectedResult) {
                     const e = protectedResult.evidence[0];
                     workspace = { id: 'station:' + e.root_digest, revision: 0, digest: e.tree_digest };
-                    deliverables = protectedResult.deliverables;
+                    // Keep each deliverable's verified bytes as a session artifact, committed with the
+                    // completion, so publication reads the verified revision and never the live workspace.
+                    deliverables = protectedResult.deliverables.map(({ path, sha256, content }) => {
+                        if (typeof content !== 'string')
+                            throw new ServiceError('verification_required', 'Deliverable bytes unavailable');
+                        const artifact = this.artifacts.prepare(task.session_id, content);
+                        artifact.commit();
+                        return { path, sha256, artifact_id: artifact.id };
+                    });
                     diff = {
                         backend: 'linux-systemd-station-v1',
                         root_digest: e.root_digest,
@@ -481,6 +510,10 @@ export class TaskVerification {
             catch (error) {
                 missing.push('Workspace verification unavailable: ' + error.message);
             }
+            // Item 8: a declared critic must have passed this exact verified evidence.
+            if (task.completion_gate?.critic &&
+                !(protectedResult && this.critic?.passed(task, digest(protectedResult.evidence))))
+                missing.push('Critic review required');
             if (missing.length && !exception)
                 throw new ServiceError('verification_required', missing.join('; '));
             if (exception) {
@@ -544,7 +577,7 @@ export class TaskVerification {
                     if (completion.state === 'succeeded')
                         fresh =
                             fresh &&
-                                task.acceptance.every((check) => {
+                                requiredChecks(task).every((check) => {
                                     const latest = this.latest(task, check.key, null);
                                     return !!latest && evidence.checks.includes(latest.id) && this.fresh(latest);
                                 });

package/dist/src/task-work.js

@@ -34,6 +34,52 @@ export class TaskWork {
             .prepare('UPDATE task_runtime SET remaining_steps=remaining_steps-1 WHERE task_id=?')
             .run(task.id);
     }
+    /** Item 8: re-run the last completed step with the critic's findings added to its instruction,
+     * under its own re-prepared progression grant and a request of its own. */
+    reopenForCritic(taskId, stepId, round, epoch, findings) {
+        const task = this.get(taskId);
+        const step = task.steps.find((s) => s.id === stepId);
+        const grant = this.store.db
+            .prepare("SELECT id FROM task_grants WHERE task_id=? AND step_id=? AND plan_revision=? AND epoch=? AND state='accepted'")
+            .get(task.id, stepId, task.plan_revision, epoch);
+        if (!grant || !step || step.state !== 'completed' || task.steps.at(-1)?.id !== stepId)
+            throw new ServiceError('task_authority', 'Only the completed last step can be reopened');
+        this.store.transaction(() => {
+            this.store.db.prepare("UPDATE task_steps SET state='pending' WHERE id=?").run(stepId);
+            this.store.db.prepare("UPDATE task_grants SET state='prepared' WHERE id=?").run(grant.id);
+            this.store.event(task.session_id, 'work_task.step_reopened', {
+                task_id: task.id,
+                step_id: stepId,
+                grant_id: grant.id,
+                round,
+                reason: 'Critic requested changes',
+            });
+        });
+        return this.run(task.id, stepId, 'task-grant:' + grant.id + ':critic-reopen:' + round, this.get(task.id).revision, step.instruction +
+            '\n\nBefore this work is accepted, a reviewer asked for these changes:\n' +
+            findings, null, null, grant.id);
+    }
+    /** Re-run a step the provider rate-limited, as a fresh attempt under its own progression grant
+     * (re-prepared, with a request of its own, so it is never a replay of the refused attempt). */
+    retryStep(taskId, stepId, n, epoch) {
+        const task = this.get(taskId);
+        const grant = this.store.db
+            .prepare("SELECT id FROM task_grants WHERE task_id=? AND step_id=? AND plan_revision=? AND epoch=? AND state='accepted'")
+            .get(task.id, stepId, task.plan_revision, epoch);
+        if (!grant || task.steps.find((s) => s.id === stepId)?.state !== 'failed')
+            throw new ServiceError('task_authority', 'No settled grant for this rate-limited step');
+        this.store.transaction(() => {
+            this.store.db.prepare("UPDATE task_grants SET state='prepared' WHERE id=?").run(grant.id);
+            this.store.event(task.session_id, 'work_task.step_retried', {
+                task_id: task.id,
+                step_id: stepId,
+                grant_id: grant.id,
+                retry: n,
+                reason: 'Provider rate limit',
+            });
+        });
+        return this.run(task.id, stepId, 'task-grant:' + grant.id + ':rate-limit-retry:' + n, task.revision, null, null, null, grant.id);
+    }
     advance(grantId) {
         const grant = this.store.db.prepare('SELECT * FROM task_grants WHERE id=?').get(grantId);
         if (!grant)
@@ -439,6 +485,7 @@ export class TaskWork {
                 objective: task.objective,
                 constraints: task.constraints,
                 acceptance: task.acceptance,
+                ...(task.completion_gate ? { completion_gate: task.completion_gate } : {}),
                 deliverables: task.deliverables,
                 limits: task.limits,
                 active_step_id: task.steps.find((s) => s.state === 'running')?.id ?? null,

package/dist/src/terminal-status.js

@@ -0,0 +1,88 @@
+import { execFile } from 'node:child_process';
+export function terminalState(snapshot) {
+    if (!snapshot)
+        return 'idle';
+    if ((snapshot.approvals ?? []).some((a) => a.state === 'pending'))
+        return 'blocked';
+    if ((snapshot.attempts ?? []).some((a) => ['accepted', 'dispatching', 'running'].includes(a.state)))
+        return 'working';
+    return 'idle';
+}
+export function titleFor(state, name) {
+    // eslint-disable-next-line no-control-regex
+    const clean = name
+        ?.replace(/[\x00-\x1f\x7f-\x9f]/g, '')
+        .trim()
+        .slice(0, 32);
+    if (!clean)
+        return 'Salaam';
+    const words = state === 'blocked' ? 'needs you' : state === 'working' ? 'working' : 'idle';
+    return `Salaam · ${clean} · ${words}`;
+}
+export function statusEnabled(env = process.env) {
+    return env.SALAAM_TERMINAL_STATUS !== 'off';
+}
+const run = (bin, args, done) => {
+    // Short timeout, failures ignored: Herdr must never slow Salaam down.
+    execFile(bin, args, { timeout: 2000, windowsHide: true }, () => done());
+};
+/** Reports to Herdr only inside a Herdr pane; one report in flight, newest state wins. */
+export class HerdrReporter {
+    env;
+    exec;
+    now;
+    enabled;
+    seq = 0;
+    busy = false;
+    queued;
+    last;
+    constructor(env = process.env, exec = run, now = Date.now) {
+        this.env = env;
+        this.exec = exec;
+        this.now = now;
+        this.enabled = !!(env.HERDR_ENV === '1' && env.HERDR_PANE_ID && env.HERDR_BIN_PATH);
+    }
+    nextSeq() {
+        this.seq = Math.max(this.seq + 1, this.now());
+        return String(this.seq);
+    }
+    head(verb) {
+        return ['pane', verb, this.env.HERDR_PANE_ID, '--source', 'salaam', '--agent', 'salaam'];
+    }
+    report(state, session) {
+        if (!this.enabled)
+            return;
+        const key = state + ' ' + (session ?? '');
+        if (key === this.last)
+            return;
+        this.last = key;
+        this.queued = [
+            ...this.head('report-agent'),
+            '--state',
+            state,
+            '--seq',
+            '',
+            ...(state === 'blocked' ? ['--message', 'Waiting for your approval'] : []),
+            ...(session ? ['--agent-session-id', session, '--', 'salaam', '--session', session] : []),
+        ];
+        this.flush();
+    }
+    release() {
+        if (!this.enabled)
+            return;
+        this.queued = undefined;
+        this.exec(this.env.HERDR_BIN_PATH, [...this.head('release-agent'), '--seq', this.nextSeq()], () => { });
+    }
+    flush() {
+        if (this.busy || !this.queued)
+            return;
+        const args = this.queued;
+        this.queued = undefined;
+        args[args.indexOf('--seq') + 1] = this.nextSeq();
+        this.busy = true;
+        this.exec(this.env.HERDR_BIN_PATH, args, () => {
+            this.busy = false;
+            this.flush();
+        });
+    }
+}