trackly-cli 0.16.0 → 0.17.0

package/lib/agent.js

@@ -8,7 +8,7 @@ const { spawnSync } = require('node:child_process');
 const { apiRequest, downloadFile, getConfigPaths, hasAuth, maintenanceOutput } = require('./client');
 const { version: PACKAGE_VERSION } = require('../package.json');
 const { contractVersion: MCP_CONTRACT_VERSION } = require('../contracts/trackly-apply-tools.json');
-const SKILL_VERSION = '4.6.0';
+const SKILL_VERSION = '4.7.0';
 const CLI_USER_AGENT = `trackly-cli/${PACKAGE_VERSION}`;
 const MCP_USER_AGENT = `trackly-mcp/${PACKAGE_VERSION}`;
 

package/mcp/apply-tools.js

@@ -263,7 +263,7 @@ const startApplyRunSchema = z.object({
   }
 });
 
-const APPLY_RELIABILITY_PROMPT = 'Protocol 3.6 / skill 4.6.0 reliability gate: recover active work first. After full local context loss, list recoverable executions, show only stable job identity, obtain explicit confirmation of the exact candidate set, and call exact-member recovery without substitutions. Treat recovered tab presence, form state, and mutation authority as three separate facts; reacquire a fresh browser binding and inspection epoch before mutation. Before resolving broad submission statements, list active review handoffs for the execution; use only an explicit receipt or the sole returned active receipt, classify every member as detected, user_confirmed, unresolved, or contradictory, and claim that exact handoff before writing outcomes. Use provider-specific positive success evidence; an unchanged URL or title is never negative evidence. Validate an exact expected browser keep set locally before finalization. For resume uploads, negotiate the browser surface capabilities, identify the semantic control, arm the chooser before clicking, attach the immediately verified file, prove the user-facing filename committed, and recheck parser-modified fields. Use compact snapshots and server-provided mutability. Preserve user-edited and unknown non-empty fields. Never reopen parked work without explicit user resumption. Never click Submit.';
+const APPLY_RELIABILITY_PROMPT = 'Protocol 3.6 / skill 4.7.0 reliability gate: recover active work first. Retain the latest explicit target as hard, prove genuine applicant fields before counting access, obtain approval for the exact accessible jobs before form mutation, fill all deterministic fields before one true-gap question packet, and validate each value-free phase checkpoint. After full local context loss, list recoverable executions, show only stable job identity, obtain explicit confirmation of the exact candidate set, and call exact-member recovery without substitutions. Treat recovered tab presence, form state, and mutation authority as three separate facts; reacquire a fresh browser binding and inspection epoch before mutation. Before resolving broad submission statements, list active review handoffs for the execution; use only an explicit receipt or the sole returned active receipt, classify every member as detected, user_confirmed, unresolved, or contradictory, and claim that exact handoff before writing outcomes. Use provider-specific positive success evidence; an unchanged URL or title is never negative evidence. Validate an exact expected browser keep set locally before finalization. For resume uploads, negotiate the browser surface capabilities, identify the semantic control, arm the chooser before clicking, attach the immediately verified file, prove the user-facing filename committed, and recheck parser-modified fields. Use compact snapshots and server-provided mutability. Preserve user-edited and unknown non-empty fields. Never reopen parked work without explicit user resumption. Never click Submit.';
 
 function registerApplyTools(
   server,
@@ -1199,7 +1199,7 @@ function registerApplyTools(
       content: { type: 'text', text: APPLY_RELIABILITY_PROMPT },
     }, {
       role: 'user',
-      content: { type: 'text', text: 'Before generating questions or filling controls, run the skill 4.6 deterministic answer resolver. Classify every visible answer as exact_profile, safe_derivation, supported_draft, missing_fact, live_consent, or forbidden_inference; validate the control type; fill only the first three; and ask only currently visible unresolved needs. Treat the current profile revision as reusable authority, never transcript, screenshot, parser, autocomplete, or cached values. Accessible-first is a hard scheduler invariant: park known authentication, account-creation, OTP, and pre-form-CAPTCHA work without starting a draft while an accessible candidate remains.' },
+      content: { type: 'text', text: 'Before generating questions or filling controls, run the skill 4.7.0 deterministic answer resolver. Classify every visible answer as exact_profile, safe_derivation, supported_draft, missing_fact, live_consent, or forbidden_inference; validate the control type; fill only the first three; and ask only currently visible unresolved needs. Treat the current profile revision as reusable authority, never transcript, screenshot, parser, autocomplete, or cached values. Accessible-first is a hard scheduler invariant: park known authentication, account-creation, OTP, and pre-form-CAPTCHA work without starting a draft while an accessible candidate remains.' },
     }, {
       role: 'user',
       content: { type: 'text', text: 'Only active=true identifies resumable execution work. Active=false and preserved=true is terminal read-only reconciliation evidence.' },
@@ -1207,7 +1207,7 @@ function registerApplyTools(
       role: 'user',
       content: {
         type: 'text',
-        text: 'Protocol 3.6.0 reliability gate for new work: require MCP contract 3.7.3 and skill 4.6.0. After complete local context loss, list bounded recovery candidates, obtain explicit confirmation of the exact set, and recover only that set. Treat tab recovery, form-state recovery, and mutation authority as independent. List active handoff receipts for the execution before resolving grouped submission statements; use the named receipt or the sole returned active receipt, classify every member, and claim that receipt before recording outcomes. Validate tab keep sets and resume upload stages locally. Never send raw browser values or click Submit.',
+        text: 'Protocol 3.6.0 reliability gate for new work: require MCP contract 3.7.3 and skill 4.7.0. After complete local context loss, list bounded recovery candidates, obtain explicit confirmation of the exact set, and recover only that set. Treat tab recovery, form-state recovery, and mutation authority as independent. List active handoff receipts for the execution before resolving grouped submission statements; use the named receipt or the sole returned active receipt, classify every member, and claim that receipt before recording outcomes. Validate tab keep sets and resume upload stages locally. Never send raw browser values or click Submit.',
       },
     }, {
       role: 'user',

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "trackly-cli",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "trackly-cli",
-      "version": "0.16.0",
+      "version": "0.17.0",
       "license": "MIT",
       "dependencies": {
         "@modelcontextprotocol/sdk": "1.30.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trackly-cli",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "mcpName": "io.github.trackly-app/trackly",
   "description": "AI job search CLI + hosted MCP server with OAuth. 170K+ jobs, 3,800+ companies, 40+ ATS. Works with Claude, ChatGPT, Cursor, Windsurf, Codex via hosted streamable-http or local stdio.",
   "bin": {

package/server.json

@@ -17,12 +17,12 @@
       ]
     }
   ],
-  "version": "0.16.0",
+  "version": "0.17.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "trackly-cli",
-      "version": "0.16.0",
+      "version": "0.17.0",
       "runtimeHint": "npx",
       "runtimeArguments": [
         {

package/skills/trackly-apply/SKILL.md

@@ -20,15 +20,22 @@ Use Trackly as the source of truth for profile answers, documents, queue decisio
 
 ## Start every run
 
-Before selecting or resuming work, read
+Before selecting, probing, or mutating work, read
+[references/operational-checkpoints.md](references/operational-checkpoints.md),
+[references/access-probe.md](references/access-probe.md),
 [references/batch-orchestration.md](references/batch-orchestration.md) and
-[references/browser-lifecycle.md](references/browser-lifecycle.md). Before generating an employer-form question packet, also read and run
+[references/browser-lifecycle.md](references/browser-lifecycle.md). Read
+[references/performance-telemetry.md](references/performance-telemetry.md) before
+reusing a form schema, grouping templates, or emitting Apply telemetry. Before generating an employer-form question packet, also read and run
 [references/answer-resolution.md](references/answer-resolution.md). These
-references define the server-frozen batch, grouped-question, tab-reconciliation,
-and missing-surface recovery contract; they are mandatory even for a one-job batch.
+references define the phase checkpoints, access state machine, server-frozen
+batch, grouped-question, tab-reconciliation, and missing-surface recovery
+contract; they are mandatory even for a one-job batch. Validate each local
+value-free phase receipt with `scripts/validate-phase-checkpoint.js` before
+claiming that phase complete.
 Read [references/legal-clarifications.md](references/legal-clarifications.md) when a form asks for a legal, regulatory, consent, or employer-relationship decision.
 
-1. Call `trackly_get_apply_protocol`. Skill 4.6.0 requires protocol 3.6.0 or newer for new reliability work. Protocol 3.2 remains valid only for an already-active explicit legacy single run; an already-active explicit 3.2 single run may finish through its legacy path. Preserve the protocol's documented recovery paths for already-active older work. Require `compatibleSkillMajor: 4` and `compatibleSkillMinimumVersion` no newer than this installed skill. Reject an older or incompatible version for new work and report that the backend must finish updating or `trackly agent setup` must update the skill. Protocol 3.2 added exact-origin trust for jobs Trackly ingested directly from employer careers sources; do not recreate the retired ownership-timestamp gate in the client.
+1. Call `trackly_get_apply_protocol`. Skill 4.7.0 requires protocol 3.6.0 or newer for new reliability work. Protocol 3.2 remains valid only for an already-active explicit legacy single run; an already-active explicit 3.2 single run may finish through its legacy path. Preserve the protocol's documented recovery paths for already-active older work. Require `compatibleSkillMajor: 4` and `compatibleSkillMinimumVersion` no newer than this installed skill. Reject an older or incompatible version for new work and report that the backend must finish updating or `trackly agent setup` must update the skill. Protocol 3.2 added exact-origin trust for jobs Trackly ingested directly from employer careers sources; do not recreate the retired ownership-timestamp gate in the client.
 2. Call `trackly_get_profile_onboarding` or fetch both the profile schema and application profile. When present, render `schema.screens` in ascending `order` as one grouped question packet per screen. Within a screen, preserve category `order` and then field `order`; use each field's user-facing `rationale` when the user asks why it is needed. Ask only unknown or confirmation-needed fields and honor `consistencyRules` before submitting profile changes, resolving contradictions with the user instead of guessing. When `schema.screens` is absent on a legacy backend, fall back to the existing category-based onboarding behavior. Treat `completeness.percent` as required onboarding readiness only. Use `coverage.missingReusableKeys` to explain reusable optional gaps, while `coverage.contextualKeys` are intentionally asked only on the relevant employer form. Do not claim that 100% required completeness answers every possible application question.
 3. Save answers with `trackly_update_application_profile`:
    - Use `answered`, `intentionally_blank`, `declined`, or `unknown` exactly.
@@ -73,7 +80,7 @@ Read [references/legal-clarifications.md](references/legal-clarifications.md) wh
    - For each fixed batch member, preserve an explicit job ID -> application run ID -> browser tab mapping. Complete the full start -> conditional resume preparation/confirmation/verification when an upload control exists -> form completion -> `review_ready` lifecycle for every member. A review-ready run does not block the next member. Never submit any of them.
 6. When the selected job or current fixed batch member has no `runId`, call `trackly_start_apply_run` with the complete `batchId`, `memberId`, `expectedMemberVersion`, `expectedInspectionEpoch`, and `leaseToken` returned by Trackly. This is the sanctioned idempotent lookup for a recovered member whose `runId` is absent; call it with the exact recovered binding and Trackly will reuse the bound active run. When the member already has a `runId`, do not call `trackly_start_apply_run` in this or any subsequent start step: reuse that exact run and bind or recover its browser surface through `trackly_bind_apply_surface` as required. Never create a replacement run because browser control was interrupted.
    - If a bound start returns a transport failure, a non-access HTTP 5xx response, or an error explicitly marked `retryable: true`, preserve the frozen member and browser state. Refetch the active batch, renew its lease, and retry the same complete binding once. Classify the retry response independently with these same rules: route canonical `maintenance_mode` or legacy `planned_maintenance` directly through **Resume after maintenance**; surface controlled-access/request errors marked `retryable: false` and every other HTTP 4xx response unchanged; only a second transport failure, non-access HTTP 5xx response, or explicitly retryable error becomes `backend_run_start_unavailable`. Route maintenance on either attempt without consuming or relabeling the retry, and never relabel a permanent retry response as an outage. For `backend_run_start_unavailable`, continue other members and report a Trackly control-plane failure. Do not call `trackly_checkpoint_apply_batch` for this condition because start failure has not produced the required run ID. The unchanged frozen member is the durable resume point. Never switch that frozen member to an unbound legacy run or blame the employer form.
-   - Require `run.protocolVersion` to be 3.1.0 or newer and to share protocol major 3 with the fetched protocol. A new reliability execution member requires 3.6.0 or newer; already-active older work may use only the recovery path published by its fetched protocol. Never continue a pre-evidence 3.0.x run under skill 4.6.0. Preserve that run instead of starting a replacement, record it `blocked` with a value-free protocol-upgrade reason when possible, and tell the user the saved job can be retried only after the stale run is cleared through Trackly's supported lifecycle. Stop and refetch the protocol and active execution or batch if support level, execution mode, provider, required scenarios, authorized origin policy, member version, or inspection epoch changes after run creation.
+   - Require `run.protocolVersion` to be 3.1.0 or newer and to share protocol major 3 with the fetched protocol. A new reliability execution member requires 3.6.0 or newer; already-active older work may use only the recovery path published by its fetched protocol. Never continue a pre-evidence 3.0.x run under skill 4.7.0. Preserve that run instead of starting a replacement, record it `blocked` with a value-free protocol-upgrade reason when possible, and tell the user the saved job can be retried only after the stale run is cleared through Trackly's supported lifecycle. Stop and refetch the protocol and active execution or batch if support level, execution mode, provider, required scenarios, authorized origin policy, member version, or inspection epoch changes after run creation.
    - In guided mode, inspect the page before preparing any resume bytes. Confirm the employer, role, HTTPS origin, reachable review path, semantic controls, whether an attachment control exists, and absence of a credential, verification, CAPTCHA, or submit-only wall. A missing file input is not itself a blocker; skip the resume path when the application has no attachment control. Any other failed precondition is an execution blocker, not permission to improvise.
 7. Pass the browser readiness gate before preparing resume bytes:
    - Use semantic browser control through Codex in-app browser controls, Chrome MCP/extension browser control, or Claude in Chrome.
@@ -123,7 +130,7 @@ Follow this order:
    - Use the canonical English school name from Trackly when the ATS offers that exact committed option. If a closed ATS selector does not offer it, select only a verified catalog option for the same institution; never leave free-typed text as though it were committed.
    - Treat partial dates as unknown at the missing precision. If Trackly has only a year but the ATS requires a month, ask once and sync the complete date before selecting either control. Never accept an ATS-selected current/default month or infer an education month.
 8. Use the canonical `consent.background_check_if_advanced` field only when the form explicitly asks for consent to a background check if the candidate advances. If it is unknown, ask before selecting it and save the answer at the user's chosen scope. Never infer it from privacy, demographic, recruiting-data, general application, criminal-record, or professional-reference consent. Treat the latter two as separate unknown consent questions unless the current profile schema supplies their own canonical fields.
-9. For a free-text application response, read [references/application-writing.md](references/application-writing.md). Draft from supported profile and role facts, assemble the complete local claim-reference packet, set `claimsComplete: true` only after confirming that the packet covers the whole draft, then call `trackly_lint_application_text`. Do not enter the answer until deterministic lint passes and every claim has a supported evidence reference. Omitting claim metadata is a blocking lint failure, including for drafts the agent believes contain no claims. Do not require a separate writing or humanizer skill.
+9. For a free-text application response, read [references/application-writing.md](references/application-writing.md). Draft from supported profile and role facts, then run Humanizer automatically when available. Treat its output as a new revision: rebuild the complete local claim-reference packet against that exact final text, set `claimsComplete: true` only after confirming that the packet covers the whole revision, and then call `trackly_lint_application_text`. Apply the self-contained gate whether or not Humanizer is available, and do not block the application merely because Humanizer is unavailable. Do not enter the answer until the exact final revision passes deterministic lint and every claim has a supported evidence reference. Omitting claim metadata is a blocking lint failure, including for drafts the agent believes contain no claims.
 10. Run the full integrity gate, including the final consent checkbox, every visible error, all steps, and any correction banner.
 
 If browser startup or file work reports `ENOSPC`, `EACCES`, quota, or another I/O error, call `trackly_diagnose_local_path` on the exact implicated path before explaining the cause. Never generalize one path failure to the whole disk without matching measured evidence.

package/skills/trackly-apply/references/access-probe.md

@@ -0,0 +1,68 @@
+# Access-probe state machine
+
+Use this reference for every candidate whose current access state is not already
+durably terminal. A provider hint is scheduling input, never sufficient proof.
+
+## States
+
+- `requisition_loaded`: the exact stored HTTPS requisition loaded and its
+  employer, role, requisition, and complete origin policy passed, including a
+  tenant only when the policy requires one.
+- `apply_entry_found`: a genuine application-entry control exists.
+- `intermediate_apply_shell`: a modal, chooser, overview, marketing shell,
+  guest landing page, resume-choice screen, or routing page. Accessibility is
+  still unknown.
+- `applicant_fields_reached`: genuine applicant controls are visible,
+  semantically editable, and reachable without credentials.
+- `authentication_required`: an existing-account login blocks applicant fields.
+- `account_creation_required`: a new account blocks applicant fields.
+- `otp_required`: email or SMS verification blocks applicant fields.
+- `captcha_before_form`: human verification blocks applicant fields.
+- `captcha_at_submit`: applicant fields are usable, but the user must solve a
+  final challenge at Submit.
+- `inactive`: the exact posting is removed, closed, or no longer accepts
+  applications.
+- `manual_only`: provider policy forbids automated form mutation.
+- `unknown_unobservable`: the adapter cannot prove committed semantic controls.
+
+## Transition contract
+
+1. Begin from only the exact backend-stored requisition URL.
+2. Validate HTTPS, employer, role, requisition, and the complete authoritative
+   origin policy. For a vendor-hosted ATS, this includes the supplied tenant
+   rule and exact verified tenant. For `trackly_employer_source_exact_origin`,
+   validate only the exact listed origin; do not invent or require an ATS tenant.
+3. Follow ordinary non-sensitive application-entry controls while remaining in
+   `intermediate_apply_shell`.
+4. Stop only at genuine applicant controls or one typed blocker. An Apply button,
+   modal, guest shell, overview, or readable job page is not access proof.
+5. Never enter private data, credentials, create an account, solve OTP or
+   CAPTCHA, or change an applicant control during the probe.
+6. Count a job as accessible only after `applicant_fields_reached` is durably
+   proven and the active contract's `accessible` disposition is durably
+   recorded. Use `accessible`, not the local state name, in the access checkpoint.
+   `captcha_at_submit` may continue through review because the user owns Submit;
+   every other access wall is parked without consuming capacity.
+7. Revalidate origin, any policy-required tenant, and exact requisition after
+   every redirect.
+8. Keep `inactive` as the exact local page observation, but do not claim that
+   Trackly stored a disposition its active contract does not expose. Under MCP
+   contract 3.7.3, persist and checkpoint the conservative non-counting
+   `unknown_unobservable` disposition with `applicantControlsObserved: false`,
+   and report the local inactive reason separately without raw page text. Use a
+   future exact `inactive` disposition only when the fetched contract exposes
+   it. Preserve a typed control-plane conflict rather than inventing a
+   replacement run.
+
+## Provider evidence
+
+| Provider or pattern | Insufficient | Accessible | Blocker |
+|---|---|---|---|
+| Greenhouse | Job description or Apply button | Editable name/contact or equivalent applicant controls on the exact tenant and requisition | Login or challenge before fields |
+| Ashby | Overview tab | Application tab with editable applicant controls | Account or challenge before controls |
+| Workday | Start Application modal or Apply Manually choice | Actual applicant-data page without a credential wall | Create Account, Sign In, OTP, or pre-form challenge means `account_creation_required`, `authentication_required`, `otp_required`, or `captcha_before_form` |
+| Adobe or Microsoft style | Readable guest landing page or application shell | Editable applicant controls before login | Login before fields means `authentication_required` |
+| Amazon | Job description and Apply button | Editable applicant fields before Amazon Jobs authentication | Amazon sign-in means `authentication_required` |
+
+When browser and accessibility surfaces disagree, use
+`unknown_unobservable`. Never upgrade uncertainty to accessibility.

package/skills/trackly-apply/references/application-writing.md

@@ -8,7 +8,18 @@ Use this reference for free-text questions such as "Why this company?", motivati
 - These fields never block an application run when they are unknown. The user can continue with the plain default style for the current run or use saved style instructions; asking the user to paste a sample is a fallback only when they explicitly want to calibrate before a completed run provides approved text.
 - Only after durable submitted/applied reconciliation, offer once to save one to three of the user's approved free-text answers as the global `writing.voice_sample`. Show which answers would be included, require an explicit yes, and save nothing on silence or ambiguity. Because the field is sensitive, make the offer only with active sensitive-storage consent; otherwise ask for consent first or skip it. If the user chooses to decline a voice sample, save `writing.voice_sample` with state `declined` at global scope and no answer text so the offer is not repeated. The user may also choose intentionally blank style instructions.
 - Treat the sample and preferences as private user data. Never copy them into the public skill, logs, observations, or another user's defaults.
-- A separate humanizer or writing skill may be used when available, but it is optional. This gate remains authoritative and self-contained.
+- When the Humanizer skill is available, run it automatically for every
+  supported employer-specific draft before the anti-slop gate. Humanizer is
+  mandatory when available; do not wait for the user to remind you. The
+  self-contained anti-slop gate remains the mandatory fallback when Humanizer
+  is unavailable and the final authority in every environment. Mark Humanizer
+  `available` only when the current session exposes the `humanizer` skill and
+  its `SKILL.md` can be read. A matching file elsewhere on disk is not runtime
+  availability. If either check fails, record `unavailable` and use the fallback.
+- After Humanizer returns, treat the result as a new draft. Discard any earlier
+  claim-reference packet, rebuild it against the exact final revision, and run
+  deterministic lint only on that same revision. Never reuse a pre-Humanizer
+  lint result or claim proof.
 
 ## Draft from evidence
 
@@ -30,7 +41,14 @@ Before entering the response:
 
 1. Remove generic praise, inflated claims, vague transitions, boilerplate conclusions, and chatbot phrases.
 2. Rewrite `not just X, but Y`, ornamental rule-of-three lists, and dangling `-ing` clauses unless the user's sample clearly uses them naturally.
-3. Resolve `writing.em_dash_policy`; unanswered defaults to `forbid`. Build the complete local claim-reference packet and set `claimsComplete: true` only after checking the whole draft. Call `trackly_lint_application_text` and treat its deterministic lint as a blocking gate. Missing claim metadata is a failure, even for an apparently claim-free draft. Never enter text with a failed lint result. `allow_if_voice_sample` requires explicit saved evidence that the approved sample uses that punctuation.
+3. Resolve `writing.em_dash_policy`; unanswered defaults to `forbid`, so the
+   default output contains no em dash. Build the complete local claim-reference
+   packet and set `claimsComplete: true` only after checking the whole draft.
+   Call `trackly_lint_application_text` and treat its deterministic lint as a
+   blocking gate. Missing claim metadata is a failure, even for an apparently
+   claim-free draft. Never enter text with a failed lint result or an unsupported
+   claim. `allow_if_voice_sample` requires explicit saved evidence that the
+   approved sample uses that punctuation.
 4. Vary sentence length and structure. Avoid a sequence of equally sized, equally formal sentences.
 5. Prefer active verbs, concrete nouns, real numbers, and named examples already supported by the profile.
 6. Read the answer aloud. If it sounds like a press release, generic cover letter, or assistant response, rewrite it.

package/skills/trackly-apply/references/operational-checkpoints.md

@@ -0,0 +1,188 @@
+# Operational checkpoints
+
+Use this page as the run card. The detailed references define how to perform
+each action; this page defines when a phase is allowed to advance.
+
+## Invariant checklist
+
+- Keep the latest explicit target as the hard target. An earlier target never
+  returns after the user changes it. A smaller interim wave is not completion;
+  continue replacements until the hard target is reached or the server proves
+  queue exhaustion.
+- Prove access to genuine applicant fields before counting a job as accessible.
+- Show the exact jobs and require them to be approved before any form mutation.
+  Approval to inspect or probe is not approval to fill.
+- After job approval, inventory and fill every known value before producing one
+  grouped question packet containing only true gaps.
+- Resolve education, employment, confirmed EEO, authorization, resume, and
+  supported writing from the current Trackly profile and evidence. Never infer
+  a restricted or jurisdiction-specific fact.
+- Run Humanizer for every supported employer-specific draft when that skill is
+  available. Always run the self-contained writing gate as the fallback and
+  final authority.
+- Never activate Submit. The user owns the final submission action.
+- Preserve every review-ready tab and unsaved draft across turns, handoffs, and
+  restarts.
+- Reconcile positive submission evidence before changing Trackly state. Close a
+  completed tab only after durable `submitted` plus `applied_confirmed` proof and
+  the saved cleanup policy.
+
+## Execution mode decision
+
+| User intent | Mode | Required behavior |
+|---|---|---|
+| Fill or apply to the next N accessible jobs | `complete_next_n_accessible` | Recover the active execution first; retain the latest explicit target; replace typed blockers until target or exhaustion. |
+| Inspect the next N queue records | Fixed inspection | Freeze exactly N records; do not replace or replenish them. |
+| Continue after tab, app, or context loss | Active recovery | Restore exact server lineage, tab state, and mutation authority as three independent receipts. |
+| Reconcile work the user already submitted | Terminal reconciliation | Record current-epoch positive evidence before outcomes; do not reopen or refill forms. |
+
+Never use the fixed-batch approval endpoint for an accessible execution. Use the
+execution-scoped resume approval required by the current protocol. Never create
+a replacement run for a member that already has one or for a queued member whose
+run start conflicts; preserve it and report the typed control-plane conflict.
+
+## Two approval gates
+
+1. **Job approval:** after non-mutating access probes prove the exact accessible
+   set, show company, role, requisition identity when available, and any shortfall
+   from the hard target. No application control may be changed before approval.
+2. **Answer approval:** after approval, fill all deterministic controls first.
+   Ask once for only `missing_fact`, `live_consent`, or user-resolvable
+   `forbidden_inference` items that are visible now. A final truthfulness
+   certification remains per run.
+
+## Phase receipts
+
+Keep these receipts local and value-free. Never include labels, answers, names,
+emails, phone numbers, URLs, resume paths, demographics, or free-text content.
+Before claiming a phase complete, resolve `<skill-dir>` as the directory that
+contains the loaded `SKILL.md`, then run from any working directory:
+
+```text
+node "<skill-dir>/scripts/validate-phase-checkpoint.js" <phase>
+```
+
+Pass `{"receipt": {...}, "expectedContext": {...}}` on standard input. The
+envelope permits only those two fields. `expectedContext` is required for every
+phase and must be built only from the current authoritative work receipt. For
+selection, include `workMode`, the authoritative `latestExplicitTarget`,
+`batchId`, `queueExhausted`, and `selectableJobIds`: the access-proven job IDs
+for an accessible execution or exact frozen member job IDs for a fixed
+inspection. Include `executionId` only for an accessible execution. For access,
+include the
+exact current `waveJobIds`, including typed blockers. For later phases, include
+the exact `approvedJobIds` from the validated selection or authoritative
+recovered approval receipt. A nonzero exit means the
+phase is not complete. The script accepts `selection`, `access`, `fill`,
+`review`, and `reconciliation`.
+
+### Selection
+
+Required fields:
+
+- `workMode`: `accessible_execution` or `fixed_inspection`;
+- positive safe-integer `batchId`, plus positive safe-integer `executionId` only
+  for an accessible execution;
+- `latestExplicitTarget`: integer 1-20 for an accessible execution, or 1-100
+  for a fixed inspection, matching the public batch-size contract;
+- `approvedJobIds`: unique positive safe-integer Trackly job IDs for the exact
+  approved set. This may be
+  empty only when the accessible queue is exhausted;
+- `approvalRecorded: true`;
+- `noFormMutationBeforeApproval: true`; and
+- `queueExhausted`: boolean. A non-empty set smaller than the target is a valid
+  interim wave; only an empty set requires this to be true.
+
+Every selection field must match `expectedContext`, and every approved job ID
+must belong to `expectedContext.selectableJobIds`. The user's approval may
+authorize a subset, but it can never introduce a job or shrink the hard target.
+
+### Access
+
+Required fields:
+
+- the same mode-specific current work lineage used by Fill: `workMode`,
+  `batchId`, `memberId`, `jobId`, `runId`, and non-negative `inspectionEpoch`,
+  plus `executionId` only for `accessible_execution`; every value must match
+  the current `expectedContext`, and `jobId` must belong to its exact
+  `waveJobIds` set. This set includes terminal blockers so their required probe
+  receipts can validate before replacement scheduling;
+- a terminal classification supported by the active durable disposition
+  contract. Under contract 3.7.3, locally observed `applicant_fields_reached`
+  uses durable `accessible`, while a locally observed `inactive` posting uses
+  conservative `unknown_unobservable`; never put either unsupported local state
+  name in the receipt or claim Trackly stored it;
+- `exactRequisitionVerified`, `originPolicyVerified`, and
+  `nonMutatingProbe` all true;
+- `privateDataEntered: false`; and
+- `applicantControlsObserved: true` only for durable `accessible` and
+  `captcha_at_submit`.
+
+### Fill
+
+Required fields:
+
+- `workMode`: `accessible_execution` or `fixed_inspection`;
+- positive safe-integer `batchId`, `memberId`, `jobId`, and `runId`, plus a
+  non-negative safe-integer `inspectionEpoch`; every value must equal the same
+  field in `expectedContext`, and `jobId` must belong to
+  `expectedContext.approvedJobIds`;
+- positive safe-integer `executionId` for `accessible_execution`, matching
+  `expectedContext`; omit it from both objects for `fixed_inspection`;
+- `visibleControlCount`, `committedControlCount`, and `typedExceptionCount` as
+  non-negative safe integers, where committed plus exceptions equals visible;
+- `knownOmissionCount: 0`;
+- `knownFieldsFilledBeforeQuestions: true`;
+- `parserSensitiveFieldsRechecked: true`;
+- `educationAndEmploymentVerified: true`;
+- `writingPresent`: boolean;
+- `localWritingGate`: `passed` when writing is present, otherwise
+  `not_applicable`;
+- `humanizerAvailability`: `available`, `unavailable`, or `not_applicable`;
+- `humanizerRan: true` when Humanizer is available;
+- `humanizerFallbackUsed: true` only when writing is present and Humanizer is
+  unavailable. This names the fallback path; `localWritingGate` is the
+  always-run final authority; and
+- `questionPacketTrueGapsOnly: true`.
+
+The fill receipt fails when any known visible control lacks either a committed
+receipt or a typed exception.
+
+### Review
+
+Required fields:
+
+- the same mode-specific lineage as Fill: `workMode`, `batchId`, `memberId`,
+  `jobId`, `runId`, and non-negative `inspectionEpoch`, plus `executionId` only
+  for `accessible_execution`; every value must match the current
+  `expectedContext`, and `jobId` must remain in its approved set;
+- `finalIntegrityPassed`, `truthConfirmationRecorded`,
+  `reviewTabPreserved`, and `userVisibleHandoffProven` all true; and
+- `submitActivated: false`.
+
+### Reconciliation
+
+Required fields:
+
+- the same mode-specific current work lineage and approved-job binding required
+  by Review. Reconciliation stays bound to the submitted run even though it is
+  a post-submission phase;
+- `positiveSubmissionEvidenceRecorded: true`;
+- `memberLifecycle: submitted`;
+- `tracklyJobStatus: applied_confirmed`;
+- `cleanupPreference`: `never`, `submitted_only`, or
+  `submitted_and_probe_blockers`;
+- `browserTabStatus`: `open`, `missing`, `closure_unverified`, or
+  `closed_verified`; `missing` records a durable missing-tab observation but is
+  not closure proof; and
+- for `closed_verified`, `completeTabInventoryRecorded`,
+  `closeReceiptRecorded`, and `postCloseUnionAbsenceProven` true.
+
+`cleanupPreference: never` forbids `closed_verified`, even when closure evidence
+exists, because evidence cannot override the user's saved no-close policy.
+For `open`, `missing`, or `closure_unverified`, all three close-proof fields must
+be false or omitted.
+
+Every final report must state the application lifecycle, Trackly job status,
+browser tab status, and whether absence is actually `closed_verified`. These
+are separate facts and none implies another.

package/skills/trackly-apply/references/performance-telemetry.md

@@ -0,0 +1,61 @@
+# Performance and value-free telemetry
+
+Improve speed only by reusing structure and batching requests. Never weaken
+identity, consent, committed-control, preservation, or Submit-boundary gates.
+
+## Value-free schema cache
+
+Cache only normalized control fingerprints, allowlisted opaque semantic-label
+codes, control types, requiredness, conditional dependencies,
+provider/tenant/template identity, interaction strategy, commit-verification
+strategy, parser/rerender risk flags, and cache version/expiry.
+
+Never cache raw semantic-label text, raw answers, contact values, demographic
+values, resume text or paths, credentials, URLs, employer-form free text, or
+any label code outside the allowlist.
+
+Invalidate on a profile revision, form schema fingerprint, inspection epoch,
+meaningful wording change, provider/tenant mismatch, or cache expiry. A cache hit
+skips structural rediscovery only; reread and verify every committed live value.
+
+## Batch resolver and template grouping
+
+- Fetch the current profile once per stable revision and request only keys
+  required by visible forms.
+- Resolve a shared question once only when scope, expected type, employer,
+  office, jurisdiction, and wording semantics all match.
+- Group same-tenant forms with identical normalized control fingerprints into
+  one structural fill plan.
+- Apply that plan independently to every exact run and tab. Keep requisition
+  identity, provenance, committed-value verification, and browser bindings
+  separate.
+- Deduplicate missing questions, not committed-control receipts.
+- Preserve bounded bulk dispositions, observations, checkpoints, and outcomes.
+  After a bulk 5xx, refetch before deciding whether to retry or split.
+
+## Events
+
+Emit these only when the current protocol or analytics surface explicitly
+supports them:
+
+- `apply_probe_stage_reached`
+- `apply_access_disposition_committed`
+- `apply_member_run_start_conflict`
+- `apply_form_schema_cache_hit`
+- `apply_form_schema_cache_miss`
+- `apply_profile_resolution_completed`
+- `apply_known_field_omitted`
+- `apply_control_commit_corrected`
+- `apply_resume_parser_repair`
+- `apply_question_packet_generated`
+- `apply_free_text_humanized`
+- `apply_handoff_receipt_committed`
+- `apply_submission_evidence_committed`
+- `apply_outcome_reconciled`
+- `apply_tab_closed_verified`
+
+Use only provider/support level, scenario code, opaque execution/member/run IDs,
+inspection epoch/version, cache hit or miss, phase elapsed time, typed error code,
+and counts by resolver class. Never include raw labels, answers, URLs, names,
+emails, phone numbers, resume paths, demographics, or free-text content. Never
+invent an event or field that the active protocol does not expose.

package/skills/trackly-apply/scripts/validate-phase-checkpoint.js

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+'use strict';
+
+const { StringDecoder } = require('node:string_decoder');
+
+const ACCESS_STATES = new Set([
+  'accessible',
+  'authentication_required',
+  'account_creation_required',
+  'otp_required',
+  'captcha_before_form',
+  'captcha_at_submit',
+  'manual_only',
+  'unknown_unobservable',
+]);
+
+const CLEANUP_PREFERENCES = new Set([
+  'never',
+  'submitted_only',
+  'submitted_and_probe_blockers',
+]);
+
+const TAB_STATES = new Set(['open', 'missing', 'closure_unverified', 'closed_verified']);
+const MAX_RECEIPT_BYTES = 64 * 1024;
+const WORK_MODES = new Set(['accessible_execution', 'fixed_inspection']);
+const COMMON_LINEAGE_FIELDS = ['workMode', 'batchId', 'memberId', 'jobId', 'runId', 'inspectionEpoch'];
+
+const PHASE_FIELDS = {
+  selection: new Set([
+    'workMode',
+    'executionId',
+    'batchId',
+    'latestExplicitTarget',
+    'approvedJobIds',
+    'approvalRecorded',
+    'noFormMutationBeforeApproval',
+    'queueExhausted',
+  ]),
+  access: new Set([
+    'workMode',
+    'executionId',
+    'batchId',
+    'memberId',
+    'jobId',
+    'runId',
+    'inspectionEpoch',
+    'classification',
+    'exactRequisitionVerified',
+    'originPolicyVerified',
+    'nonMutatingProbe',
+    'privateDataEntered',
+    'applicantControlsObserved',
+  ]),
+  fill: new Set([
+    'workMode',
+    'executionId',
+    'batchId',
+    'memberId',
+    'jobId',
+    'runId',
+    'inspectionEpoch',
+    'visibleControlCount',
+    'committedControlCount',
+    'typedExceptionCount',
+    'knownOmissionCount',
+    'knownFieldsFilledBeforeQuestions',
+    'parserSensitiveFieldsRechecked',
+    'educationAndEmploymentVerified',
+    'writingPresent',
+    'localWritingGate',
+    'humanizerAvailability',
+    'humanizerRan',
+    'humanizerFallbackUsed',
+    'questionPacketTrueGapsOnly',
+  ]),
+  review: new Set([
+    'workMode',
+    'executionId',
+    'batchId',
+    'memberId',
+    'jobId',
+    'runId',
+    'inspectionEpoch',
+    'finalIntegrityPassed',
+    'truthConfirmationRecorded',
+    'submitActivated',
+    'reviewTabPreserved',
+    'userVisibleHandoffProven',
+  ]),
+  reconciliation: new Set([
+    'workMode',
+    'executionId',
+    'batchId',
+    'memberId',
+    'jobId',
+    'runId',
+    'inspectionEpoch',
+    'positiveSubmissionEvidenceRecorded',
+    'memberLifecycle',
+    'tracklyJobStatus',
+    'cleanupPreference',
+    'browserTabStatus',
+    'completeTabInventoryRecorded',
+    'closeReceiptRecorded',
+    'postCloseUnionAbsenceProven',
+  ]),
+};
+
+function requireTrue(errors, receipt, field) {
+  if (receipt[field] !== true) errors.push(`${field} must be true`);
+}
+
+function requireFalse(errors, receipt, field) {
+  if (receipt[field] !== false) errors.push(`${field} must be false`);
+}
+
+function requireTracklyId(errors, receipt, field) {
+  if (!Number.isSafeInteger(receipt[field]) || receipt[field] < 1) {
+    errors.push(`${field} must be a positive safe integer`);
+  }
+}
+
+function requireCount(errors, receipt, field) {
+  if (!Number.isSafeInteger(receipt[field]) || receipt[field] < 0) {
+    errors.push(`${field} must be a non-negative safe integer`);
+  }
+}
+
+function validateCurrentLineage(errors, receipt, expectedContext, jobSetField = 'approvedJobIds') {
+  if (!WORK_MODES.has(receipt.workMode)) errors.push('workMode must be accessible_execution or fixed_inspection');
+  for (const field of ['batchId', 'memberId', 'jobId', 'runId']) requireTracklyId(errors, receipt, field);
+  if (!Number.isSafeInteger(receipt.inspectionEpoch) || receipt.inspectionEpoch < 0) {
+    errors.push('inspectionEpoch must be a non-negative safe integer');
+  }
+  if (receipt.workMode === 'accessible_execution') {
+    requireTracklyId(errors, receipt, 'executionId');
+  } else if (receipt.workMode === 'fixed_inspection' && Object.hasOwn(receipt, 'executionId')) {
+    errors.push('executionId must be omitted for fixed_inspection');
+  }
+  if (!expectedContext || typeof expectedContext !== 'object' || Array.isArray(expectedContext)) {
+    errors.push('expectedContext is required');
+    return;
+  }
+  const expectedFields = new Set([...COMMON_LINEAGE_FIELDS, jobSetField]);
+  if (receipt.workMode === 'accessible_execution') expectedFields.add('executionId');
+  for (const field of Object.keys(expectedContext)) {
+    if (!expectedFields.has(field)) errors.push(`unexpected expectedContext field: ${field}`);
+  }
+  for (const field of COMMON_LINEAGE_FIELDS) {
+    if (receipt[field] !== expectedContext[field]) errors.push(`${field} must match expectedContext`);
+  }
+  if (receipt.workMode === 'accessible_execution'
+      && receipt.executionId !== expectedContext.executionId) {
+    errors.push('executionId must match expectedContext');
+  }
+  if (receipt.workMode === 'fixed_inspection' && Object.hasOwn(expectedContext, 'executionId')) {
+    errors.push('expectedContext.executionId must be omitted for fixed_inspection');
+  }
+  if (!Array.isArray(expectedContext[jobSetField])
+      || expectedContext[jobSetField].some((id) => !Number.isSafeInteger(id) || id < 1)) {
+    errors.push(`expectedContext.${jobSetField} must contain positive safe integers`);
+  } else if (!expectedContext[jobSetField].includes(receipt.jobId)) {
+    errors.push(`jobId must belong to expectedContext.${jobSetField}`);
+  }
+}
+
+function validateSelection(receipt, expectedContext) {
+  const errors = [];
+  if (!WORK_MODES.has(receipt.workMode)) {
+    errors.push('workMode must be accessible_execution or fixed_inspection');
+  }
+  requireTracklyId(errors, receipt, 'batchId');
+  if (receipt.workMode === 'accessible_execution') {
+    requireTracklyId(errors, receipt, 'executionId');
+  } else if (receipt.workMode === 'fixed_inspection' && Object.hasOwn(receipt, 'executionId')) {
+    errors.push('executionId must be omitted for fixed_inspection');
+  }
+  const maximumTarget = receipt.workMode === 'fixed_inspection' ? 100 : 20;
+  if (!Number.isInteger(receipt.latestExplicitTarget)
+      || receipt.latestExplicitTarget < 1
+      || receipt.latestExplicitTarget > maximumTarget) {
+    errors.push(`latestExplicitTarget must be an integer from 1 to ${maximumTarget} for ${receipt.workMode || 'the selected work mode'}`);
+  }
+  if (!Array.isArray(receipt.approvedJobIds)) {
+    errors.push('approvedJobIds must be an array');
+  } else {
+    if (Number.isInteger(receipt.latestExplicitTarget)
+        && receipt.approvedJobIds.length > receipt.latestExplicitTarget) {
+      errors.push('approvedJobIds must not exceed latestExplicitTarget');
+    }
+    const normalized = receipt.approvedJobIds.filter((id) => Number.isSafeInteger(id) && id > 0);
+    if (normalized.length !== receipt.approvedJobIds.length) errors.push('approvedJobIds must contain positive safe integers');
+    if (new Set(normalized).size !== normalized.length) errors.push('approvedJobIds must be unique');
+    if (receipt.approvedJobIds.length === 0 && receipt.queueExhausted !== true) {
+      errors.push('approvedJobIds may be empty only when queueExhausted is true');
+    }
+  }
+  requireTrue(errors, receipt, 'approvalRecorded');
+  requireTrue(errors, receipt, 'noFormMutationBeforeApproval');
+  if (typeof receipt.queueExhausted !== 'boolean') errors.push('queueExhausted must be a boolean');
+  if (!expectedContext || typeof expectedContext !== 'object' || Array.isArray(expectedContext)) {
+    errors.push('expectedContext is required');
+    return errors;
+  }
+  const expectedFields = new Set(['workMode', 'batchId', 'latestExplicitTarget', 'selectableJobIds', 'queueExhausted']);
+  if (receipt.workMode === 'accessible_execution') expectedFields.add('executionId');
+  for (const field of Object.keys(expectedContext)) {
+    if (!expectedFields.has(field)) errors.push(`unexpected expectedContext field: ${field}`);
+  }
+  if (receipt.workMode !== expectedContext.workMode) errors.push('workMode must match expectedContext');
+  if (receipt.batchId !== expectedContext.batchId) errors.push('batchId must match expectedContext');
+  if (receipt.workMode === 'accessible_execution'
+      && receipt.executionId !== expectedContext.executionId) {
+    errors.push('executionId must match expectedContext');
+  }
+  if (receipt.workMode === 'fixed_inspection' && Object.hasOwn(expectedContext, 'executionId')) {
+    errors.push('expectedContext.executionId must be omitted for fixed_inspection');
+  }
+  if (receipt.latestExplicitTarget !== expectedContext.latestExplicitTarget) {
+    errors.push('latestExplicitTarget must match expectedContext');
+  }
+  if (receipt.queueExhausted !== expectedContext.queueExhausted) {
+    errors.push('queueExhausted must match expectedContext');
+  }
+  if (!Array.isArray(expectedContext.selectableJobIds)
+      || expectedContext.selectableJobIds.some((id) => !Number.isSafeInteger(id) || id < 1)
+      || new Set(expectedContext.selectableJobIds).size !== expectedContext.selectableJobIds.length) {
+    errors.push('expectedContext.selectableJobIds must contain unique positive safe integers');
+  } else if (Array.isArray(receipt.approvedJobIds)
+      && receipt.approvedJobIds.some((id) => !expectedContext.selectableJobIds.includes(id))) {
+    errors.push('approvedJobIds must belong to expectedContext.selectableJobIds');
+  }
+  return errors;
+}
+
+function validateAccess(receipt, expectedContext) {
+  const errors = [];
+  validateCurrentLineage(errors, receipt, expectedContext, 'waveJobIds');
+  if (!ACCESS_STATES.has(receipt.classification)) errors.push('classification must be a terminal access state');
+  requireTrue(errors, receipt, 'exactRequisitionVerified');
+  requireTrue(errors, receipt, 'originPolicyVerified');
+  requireTrue(errors, receipt, 'nonMutatingProbe');
+  requireFalse(errors, receipt, 'privateDataEntered');
+  if (['accessible', 'captcha_at_submit'].includes(receipt.classification)) {
+    requireTrue(errors, receipt, 'applicantControlsObserved');
+  } else {
+    requireFalse(errors, receipt, 'applicantControlsObserved');
+  }
+  return errors;
+}
+
+function validateFill(receipt, expectedContext) {
+  const errors = [];
+  validateCurrentLineage(errors, receipt, expectedContext);
+  for (const field of ['visibleControlCount', 'committedControlCount', 'typedExceptionCount', 'knownOmissionCount']) {
+    requireCount(errors, receipt, field);
+  }
+  if (Number.isSafeInteger(receipt.visibleControlCount)
+      && Number.isSafeInteger(receipt.committedControlCount)
+      && Number.isSafeInteger(receipt.typedExceptionCount)
+      && receipt.committedControlCount + receipt.typedExceptionCount !== receipt.visibleControlCount) {
+    errors.push('committedControlCount plus typedExceptionCount must equal visibleControlCount');
+  }
+  if (receipt.knownOmissionCount !== 0) errors.push('knownOmissionCount must be 0');
+  requireTrue(errors, receipt, 'knownFieldsFilledBeforeQuestions');
+  requireTrue(errors, receipt, 'parserSensitiveFieldsRechecked');
+  requireTrue(errors, receipt, 'educationAndEmploymentVerified');
+  if (typeof receipt.writingPresent !== 'boolean') errors.push('writingPresent must be a boolean');
+  if (!['passed', 'not_applicable'].includes(receipt.localWritingGate)) {
+    errors.push('localWritingGate must be passed or not_applicable');
+  }
+  if (!['available', 'unavailable', 'not_applicable'].includes(receipt.humanizerAvailability)) {
+    errors.push('humanizerAvailability is invalid');
+  }
+  if (typeof receipt.humanizerRan !== 'boolean') errors.push('humanizerRan must be a boolean');
+  if (typeof receipt.humanizerFallbackUsed !== 'boolean') errors.push('humanizerFallbackUsed must be a boolean');
+  if (receipt.writingPresent === true) {
+    if (receipt.localWritingGate !== 'passed') errors.push('localWritingGate must pass when writing is present');
+    if (receipt.humanizerAvailability === 'available') {
+      requireTrue(errors, receipt, 'humanizerRan');
+      requireFalse(errors, receipt, 'humanizerFallbackUsed');
+    } else if (receipt.humanizerAvailability === 'unavailable') {
+      requireFalse(errors, receipt, 'humanizerRan');
+      requireTrue(errors, receipt, 'humanizerFallbackUsed');
+    } else {
+      errors.push('humanizerAvailability must be available or unavailable when writing is present');
+    }
+  } else if (receipt.writingPresent === false) {
+    if (receipt.localWritingGate !== 'not_applicable') errors.push('localWritingGate must be not_applicable when writing is absent');
+    if (receipt.humanizerAvailability !== 'not_applicable') errors.push('humanizerAvailability must be not_applicable when writing is absent');
+    requireFalse(errors, receipt, 'humanizerRan');
+    requireFalse(errors, receipt, 'humanizerFallbackUsed');
+  }
+  requireTrue(errors, receipt, 'questionPacketTrueGapsOnly');
+  return errors;
+}
+
+function validateReview(receipt, expectedContext) {
+  const errors = [];
+  validateCurrentLineage(errors, receipt, expectedContext);
+  requireTrue(errors, receipt, 'finalIntegrityPassed');
+  requireTrue(errors, receipt, 'truthConfirmationRecorded');
+  requireFalse(errors, receipt, 'submitActivated');
+  requireTrue(errors, receipt, 'reviewTabPreserved');
+  requireTrue(errors, receipt, 'userVisibleHandoffProven');
+  return errors;
+}
+
+function validateReconciliation(receipt, expectedContext) {
+  const errors = [];
+  validateCurrentLineage(errors, receipt, expectedContext);
+  requireTrue(errors, receipt, 'positiveSubmissionEvidenceRecorded');
+  if (receipt.memberLifecycle !== 'submitted') errors.push('memberLifecycle must be submitted');
+  if (receipt.tracklyJobStatus !== 'applied_confirmed') errors.push('tracklyJobStatus must be applied_confirmed');
+  if (!CLEANUP_PREFERENCES.has(receipt.cleanupPreference)) errors.push('cleanupPreference is invalid');
+  if (!TAB_STATES.has(receipt.browserTabStatus)) errors.push('browserTabStatus is invalid');
+  if (receipt.cleanupPreference === 'never' && receipt.browserTabStatus === 'closed_verified') {
+    errors.push('browserTabStatus cannot be closed_verified when cleanupPreference is never');
+  }
+  if (receipt.browserTabStatus === 'closed_verified') {
+    requireTrue(errors, receipt, 'completeTabInventoryRecorded');
+    requireTrue(errors, receipt, 'closeReceiptRecorded');
+    requireTrue(errors, receipt, 'postCloseUnionAbsenceProven');
+  } else {
+    for (const field of ['completeTabInventoryRecorded', 'closeReceiptRecorded', 'postCloseUnionAbsenceProven']) {
+      if (Object.hasOwn(receipt, field) && receipt[field] !== false) {
+        errors.push(`${field} must be false or omitted unless browserTabStatus is closed_verified`);
+      }
+    }
+  }
+  return errors;
+}
+
+const VALIDATORS = {
+  selection: validateSelection,
+  access: validateAccess,
+  fill: validateFill,
+  review: validateReview,
+  reconciliation: validateReconciliation,
+};
+
+function validateCheckpoint(phase, receipt, expectedContext) {
+  if (!Object.hasOwn(VALIDATORS, phase)) return [`unknown phase: ${phase}`];
+  if (!receipt || typeof receipt !== 'object' || Array.isArray(receipt)) return ['receipt must be a JSON object'];
+  const unexpectedFields = Object.keys(receipt)
+    .filter((field) => !PHASE_FIELDS[phase].has(field))
+    .map((field) => `unexpected field: ${field}`);
+  return [...unexpectedFields, ...VALIDATORS[phase](receipt, expectedContext)];
+}
+
+async function readReceiptInput(stream) {
+  const decoder = new StringDecoder('utf8');
+  let input = '';
+  let inputBytes = 0;
+  let oversized = false;
+  for await (const chunk of stream) {
+    if (oversized) continue;
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    inputBytes += bytes.length;
+    if (inputBytes > MAX_RECEIPT_BYTES) {
+      oversized = true;
+      input = '';
+      continue;
+    }
+    input += decoder.write(bytes);
+  }
+  if (!oversized) input += decoder.end();
+  return { input, oversized };
+}
+
+async function main() {
+  const phase = process.argv[2];
+  if (process.stdin.isTTY) {
+    process.stderr.write('receipt envelope must be provided on standard input\n');
+    process.exitCode = 1;
+    return;
+  }
+  const { input, oversized } = await readReceiptInput(process.stdin);
+  if (oversized) {
+    process.stderr.write(`receipt must be at most ${MAX_RECEIPT_BYTES} bytes\n`);
+    process.exitCode = 1;
+    return;
+  }
+  let envelope;
+  try {
+    envelope = JSON.parse(input);
+  } catch (_) {
+    process.stderr.write('receipt must be valid JSON\n');
+    process.exitCode = 1;
+    return;
+  }
+  if (!envelope || typeof envelope !== 'object' || Array.isArray(envelope)
+      || !Object.hasOwn(envelope, 'receipt')) {
+    process.stderr.write('input must be an envelope with receipt and optional expectedContext\n');
+    process.exitCode = 1;
+    return;
+  }
+  const unexpectedEnvelopeFields = Object.keys(envelope)
+    .filter((field) => !['receipt', 'expectedContext'].includes(field));
+  if (unexpectedEnvelopeFields.length > 0) {
+    process.stderr.write(`${unexpectedEnvelopeFields.map((field) => `unexpected envelope field: ${field}`).join('\n')}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  const errors = validateCheckpoint(phase, envelope.receipt, envelope.expectedContext);
+  if (errors.length > 0) {
+    process.stderr.write(`${errors.join('\n')}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`${phase} checkpoint valid\n`);
+}
+
+if (require.main === module) {
+  main().catch(() => {
+    process.stderr.write('unable to read receipt\n');
+    process.exitCode = 1;
+  });
+}
+
+module.exports = { readReceiptInput, validateCheckpoint };