trackly-cli 0.16.0 → 0.17.1

package/bin/trackly

@@ -15,7 +15,7 @@ const {
   removeCredentials,
   saveConfig,
 } = require('../lib/client');
-const { color, isJSON, outputJobs, outputCompanies, outputStats, outputContacts, outputReferralCampaign, outputNetworkBrief, outputCompanyBrief, outputCompanyWorkspace, outputError } = require('../lib/formatters');
+const { color, isJSON, jobDateDetailLines, outputJobs, outputCompanies, outputStats, outputContacts, outputReferralCampaign, outputNetworkBrief, outputCompanyBrief, outputCompanyWorkspace, outputError } = require('../lib/formatters');
 const http = require('http');
 const crypto = require('crypto');
 const { spawnSync } = require('child_process');
@@ -665,7 +665,7 @@ async function cmdJob(args) {
     console.log(`Company: ${color('blue', job.companyName || (job.company && job.company.name) || '')}`);
     if (job.location) console.log(`Location: ${job.location}`);
     if (job.jobUrl) console.log(`URL: ${color('dim', job.jobUrl)}`);
-    if (job.postedAt) console.log(`Posted: ${job.postedAt}`);
+    for (const line of jobDateDetailLines(job)) console.log(line);
     // Field presence, not truthiness: a returned null/'unknown' status is a real
     // "Not mentioned" answer from the backend. Only an older backend that omits
     // the key entirely should render no Sponsorship line at all.

package/contracts/trackly-apply-contract-history.json

@@ -23,5 +23,14 @@
   },
   "3.7.3": {
     "contractSha256": "d37e7ec0a17d3dba399f12dd7281c51536ca92bbb21125ca09288d1678f34c14"
+  },
+  "3.7.4": {
+    "contractSha256": "b9da194f5d2a02afda339b271a2c5ed8e78b538b3d95ba8df54b14408bf49d8f"
+  },
+  "3.7.5": {
+    "contractSha256": "13997fd0496035bfa2db1d8ba9b52ff326f880e8bea3231a3c9a7fec26ddc1a7"
+  },
+  "3.7.6": {
+    "contractSha256": "259f4c0b52739956fced3936e36792b27960dcad820659994f3e9107453a5844"
   }
 }

package/contracts/trackly-apply-tools.json

@@ -1,15 +1,18 @@
 {
-  "contractVersion": "3.7.3",
+  "contractVersion": "3.7.6",
   "constants": {
     "applyExecutionMaxTarget": 20,
     "applyScenarioCodes": ["browser_reclaim", "resume_upload", "resume_parser_recheck", "semantic_boolean_commit", "custom_select_commit", "multi_step_navigation", "free_text_voice", "required_error_sweep", "final_consent", "handoff_reclaim", "critical_contact_integrity", "manual_submit_boundary", "job_identity_match"],
     "applyBrowserSurfaces": ["codex_in_app", "chrome_extension", "claude_in_chrome"],
     "applyCheckpointActionCodes": ["answer/unknown", "auth/sign_in", "auth/account_creation", "auth/otp", "captcha/before_form", "captcha/at_submit", "artifact/upload_required", "legal/decision_required", "consent/decision_required", "review/manual_submit", "trust/origin_mismatch", "observability/unverifiable_state"],
+    "applyCheckpointContinuationByAction": {"answer/unknown": true, "auth/sign_in": true, "auth/account_creation": true, "auth/otp": true, "captcha/before_form": true, "captcha/at_submit": false, "artifact/upload_required": true, "legal/decision_required": true, "consent/decision_required": true, "review/manual_submit": false, "trust/origin_mismatch": false, "observability/unverifiable_state": false},
+    "applyCheckpointLifecycleByAction": {"answer/unknown": "needs_input", "auth/sign_in": "needs_input", "auth/account_creation": "needs_input", "auth/otp": "needs_input", "captcha/before_form": "needs_input", "captcha/at_submit": "review_ready", "artifact/upload_required": "needs_input", "legal/decision_required": "needs_input", "consent/decision_required": "needs_input", "review/manual_submit": "review_ready", "trust/origin_mismatch": "blocked", "observability/unverifiable_state": "blocked"},
+    "applyCheckpointQuestionPacketByAction": {"answer/unknown": true, "auth/sign_in": false, "auth/account_creation": false, "auth/otp": false, "captcha/before_form": false, "captcha/at_submit": false, "artifact/upload_required": false, "legal/decision_required": true, "consent/decision_required": true, "review/manual_submit": false, "trust/origin_mismatch": false, "observability/unverifiable_state": false},
     "applyAccessClassifications": ["accessible", "authentication_required", "account_creation_required", "otp_required", "captcha_before_form", "captcha_at_submit", "manual_only", "unknown_unobservable"],
     "applyExecutionDispositionSources": ["live_probe"],
     "applyProbeCleanupPreferences": ["never", "submitted_only", "submitted_and_probe_blockers"],
     "applyExecutionStopReasonCodes": ["user_requested", "target_changed", "session_ended", "execution_restarted", "operator_stop"],
-    "applyBatchConflictCodes": ["state_changed", "lease_unavailable", "idempotency_key_reused", "fixed_batch_not_found", "execution_child_batch", "fixed_batch_not_active", "fixed_batch_revision_changed", "submission_in_progress", "attestation_dependencies_changed", "legacy_fixed_batch_active", "dedicated_recovery_required"],
+    "applyBatchConflictCodes": ["state_changed", "lease_unavailable", "idempotency_key_reused", "fixed_batch_not_found", "execution_child_batch", "fixed_batch_not_active", "fixed_batch_revision_changed", "submission_in_progress", "attestation_dependencies_changed", "legacy_fixed_batch_active", "dedicated_recovery_required", "recovery_migration_not_ready"],
     "fixedApplyBatchCancelReasonCodes": ["user_requested_restart"],
     "applyCheckpointPacketPhases": ["first_pass", "delta"],
     "applySurfaceBindingReasons": ["initial_binding", "recovery_binding"],
@@ -24,10 +27,20 @@
     "applyUploadFailureCodes": ["upload_capability_unavailable", "upload_stage_missing", "upload_stage_out_of_order", "upload_stage_duplicate", "control_ambiguous", "chooser_timeout", "chooser_open_without_commit", "file_missing", "file_expired", "set_files_failed", "filename_uncommitted", "unexpected_file_navigation", "parser_unsettled", "parser_field_regression"]
   },
   "toolInputInvariants": {
+    "trackly_checkpoint_apply_batch": {
+      "questionAndNonQuestionActionsMutuallyExclusiveForNewCheckpoints": true,
+      "exactReplayOfPreviouslyAcceptedPayloadPreserved": true,
+      "preFormAuthenticationWallsRejectedAfterExactReplayLookup": true
+    },
     "trackly_get_apply_execution_snapshot": {
       "officeProjectionMemberIdsMustExistInMemberIds": true
     }
   },
+  "schemaDigests": {
+    "applyCheckpointActionVariant": "db6b69924b791b3e50c4c7464519fa1a786c7b39ed86c3cc9482e18c211553d2",
+    "applyCheckpointActionSchema": "99baf25b27ae4bd41183bf47f8e1eb7522e1d471156f6090a784362d5b248e95",
+    "applyCheckpointSchema": "101c5d7606cb902e89e677773fa45fbbdc9b38de99b452d641806bac90004274"
+  },
   "tools": {
     "trackly_get_apply_queue": "{limit:z.number().int().min(1).max(100).optional(),cursor:z.string().min(1).max(2048).optional()}",
     "trackly_get_application_profile": "{includeSensitive:z.boolean().optional(),provider:z.string().max(100).optional(),companyId:z.string().max(100).optional(),jurisdiction:iso3166Alpha2Schema.optional(),office:officeScopeSchema.optional()}",
@@ -51,7 +64,7 @@
     "trackly_get_active_apply_batch": "{limit:z.number().int().min(1).max(APPLY_BATCH_MAX_MEMBERS).optional(),cursor:z.string().min(1).max(2048).optional(),actionLimit:z.number().int().min(1).max(APPLY_BATCH_MAX_MEMBERS).optional(),actionCursor:z.string().min(1).max(2048).optional()}",
     "trackly_get_apply_batch": "{batchId:z.number().int().min(1),limit:z.number().int().min(1).max(APPLY_BATCH_MAX_MEMBERS).optional(),cursor:z.string().min(1).max(2048).optional(),actionLimit:z.number().int().min(1).max(APPLY_BATCH_MAX_MEMBERS).optional(),actionCursor:z.string().min(1).max(2048).optional()}",
     "trackly_claim_apply_batch": "{batchId:z.number().int().min(1),expectedRevision:z.number().int().min(1),leaseOwner:z.string().min(1).max(1024),leaseToken:z.string().min(1).max(1024),leaseDurationMs:z.number().int().min(15000).max(300000)}",
-    "trackly_checkpoint_apply_batch": "{batchId:z.number().int().min(1),leaseToken:z.string().min(1).max(1024),checkpoints:z.array(z.object({memberId:z.number().int().min(1),runId:z.number().int().min(1),expectedMemberVersion:z.number().int().min(1),expectedInspectionEpoch:z.number().int().min(0),inspectionEpoch:z.number().int().min(0),packetPhase:z.enum(APPLY_CHECKPOINT_PACKET_PHASES).optional(),knownFieldsCommitted:z.boolean(),resolvedActionIds:z.array(z.string().regex(/^[1-9][0-9]*$/)).max(APPLY_BATCH_MAX_ACTIONS_PER_CHECKPOINT).optional(),idempotencyKey:z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY),actions:z.array(z.object({actionCode:z.enum(APPLY_CHECKPOINT_ACTION_CODES),continuationAllowed:z.boolean(),fieldFingerprint:z.string().regex(/^[a-f0-9]{64}$/).optional()})).min(1).max(APPLY_BATCH_MAX_ACTIONS_PER_CHECKPOINT)})).min(1).max(APPLY_BATCH_MAX_CHECKPOINTS_PER_REQUEST)}",
+    "trackly_checkpoint_apply_batch": "{batchId:z.number().int().min(1),leaseToken:z.string().min(1).max(1024),checkpoints:z.array(applyCheckpointSchema).min(1).max(APPLY_BATCH_MAX_CHECKPOINTS_PER_REQUEST)}",
     "trackly_bind_apply_surface": "{batchId:z.number().int().min(1),memberId:z.number().int().min(1),runId:z.number().int().min(1),expectedMemberVersion:z.number().int().min(1),expectedInspectionEpoch:z.number().int().min(0),leaseToken:z.string().min(1).max(1024),browserBindingHash:z.string().regex(/^[a-f0-9]{64}$/),browserSurface:z.enum(APPLY_BROWSER_SURFACES),adapterCode:z.string().regex(SAFE_OBSERVATION_CODE),bindingReason:z.enum(APPLY_SURFACE_BINDING_REASONS),idempotencyKey:z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY)}",
     "trackly_record_apply_surface_evidence": "{batchId:z.number().int().min(1),memberId:z.number().int().min(1),runId:z.number().int().min(1),expectedMemberVersion:z.number().int().min(1),expectedInspectionEpoch:z.number().int().min(1),leaseToken:z.string().min(1).max(1024),browserBindingHash:z.string().regex(/^[a-f0-9]{64}$/),browserSurface:z.enum(APPLY_BROWSER_SURFACES),adapterCode:z.string().regex(SAFE_OBSERVATION_CODE),ownershipState:z.enum(APPLY_SURFACE_OWNERSHIP_STATES),completeInventory:z.boolean(),evidenceType:z.enum(APPLY_SURFACE_EVIDENCE_TYPES),idempotencyKey:z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY)}",
     "trackly_record_apply_submission_evidence": "{batchId:z.number().int().min(1),memberId:z.number().int().min(1),runId:z.number().int().min(1),expectedMemberVersion:z.number().int().min(1),expectedInspectionEpoch:z.number().int().min(1),leaseToken:z.string().min(1).max(1024),browserBindingHash:z.string().regex(/^[a-f0-9]{64}$/),evidenceType:z.enum(APPLY_SUBMISSION_EVIDENCE_TYPES),evidenceSource:z.enum(APPLY_SUBMISSION_EVIDENCE_SOURCES),evidenceFingerprint:z.string().regex(/^[a-f0-9]{64}$/),idempotencyKey:z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY)}",

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.1';
 const CLI_USER_AGENT = `trackly-cli/${PACKAGE_VERSION}`;
 const MCP_USER_AGENT = `trackly-mcp/${PACKAGE_VERSION}`;
 

package/lib/formatters.js

@@ -44,6 +44,107 @@ function formatFundingLine(company) {
   return parts.length > 0 ? parts.join(' | ') : null;
 }
 
+function validCalendarDay(value) {
+  if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
+  const parsed = new Date(`${value}T00:00:00.000Z`);
+  return Number.isNaN(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== value
+    ? null
+    : value;
+}
+
+function isoCalendarDay(value) {
+  if (typeof value !== 'string' || value.trim() === '') return null;
+  const normalized = value.trim();
+  const sourceDay = validCalendarDay(normalized.slice(0, 10));
+  if (!sourceDay) return null;
+  const parsed = new Date(normalized);
+  return Number.isNaN(parsed.getTime()) ? null : sourceDay;
+}
+
+function sourceCalendarDay(job, kind) {
+  const meta = kind === 'posted'
+    ? job && job.sourceDateMeta && job.sourceDateMeta.original
+    : kind === 'reposted'
+      ? job && job.sourceDateMeta && job.sourceDateMeta.repost
+      : null;
+  return meta && meta.precision === 'day'
+    ? validCalendarDay(meta.calendarDay)
+    : null;
+}
+
+function resolveJobDateBundle(job = {}) {
+  const projectedKind = ['posted', 'reposted', 'found'].includes(job.displayDateKind)
+    ? job.displayDateKind
+    : null;
+  const projectedDay = projectedKind
+    ? sourceCalendarDay(job, projectedKind) || isoCalendarDay(job.displayDate)
+    : null;
+  const originalDay = sourceCalendarDay(job, 'posted') || isoCalendarDay(job.originalPostedAt);
+  const repostDay = sourceCalendarDay(job, 'reposted') || isoCalendarDay(job.repostedAt)
+    || (projectedKind === 'reposted' ? projectedDay : null);
+  const legacyPostedDay = isoCalendarDay(job.postedAt || job.posted_at);
+  const foundDay = isoCalendarDay(job.firstSeenAt || job.first_seen_at);
+  const presentation = projectedKind && projectedDay
+    ? {
+      label: { posted: 'Posted', reposted: 'Reposted', found: 'Found' }[projectedKind],
+      value: projectedDay,
+    }
+    : legacyPostedDay
+      ? { label: 'Posted', value: legacyPostedDay }
+      : { label: 'Found', value: foundDay || 'unknown' };
+  return {
+    projectedKind,
+    projectedDay,
+    originalDay,
+    repostDay,
+    legacyPostedDay,
+    foundDay,
+    presentation,
+  };
+}
+
+function jobDatePresentation(job = {}) {
+  return resolveJobDateBundle(job).presentation;
+}
+
+function jobDateDetailLines(job = {}) {
+  const lines = [];
+  const {
+    projectedKind,
+    projectedDay,
+    originalDay,
+    repostDay,
+    legacyPostedDay,
+    foundDay,
+    presentation,
+  } = resolveJobDateBundle(job);
+  if (originalDay) lines.push(`Posted: ${originalDay}`);
+  else if (repostDay && legacyPostedDay) lines.push(`Posted: ${legacyPostedDay}`);
+  else if (repostDay) lines.push('Original posting date unavailable');
+  else if (projectedKind === 'posted' && projectedDay) lines.push(`Posted: ${projectedDay}`);
+  else if ((!projectedKind || !projectedDay) && legacyPostedDay) {
+    lines.push(`Posted: ${legacyPostedDay}`);
+  }
+  if (foundDay) lines.push(`Found: ${foundDay}`);
+  else if (lines.length === 0 && !originalDay && !repostDay) {
+    if (presentation.value !== 'unknown') {
+      lines.push(`${presentation.label}: ${presentation.value}`);
+    }
+  }
+  if (repostDay) lines.push(`Reposted: ${repostDay}`);
+  const requirement = sourceRequirement(job);
+  if (requirement) lines.push(`Req: ${requirement}`);
+  return lines;
+}
+
+function sourceRequirement(job = {}) {
+  const reference = job.sourceReference;
+  return reference && reference.label === 'Req' && reference.disambiguatesTitle === true
+    && typeof reference.value === 'string' && reference.value.trim()
+    ? reference.value.trim()
+    : null;
+}
+
 function outputJobs(jobs) {
   if (isJSON()) return console.log(JSON.stringify(jobs, null, 2));
   if (!jobs || jobs.length === 0) {
@@ -57,7 +158,10 @@ function outputJobs(jobs) {
     console.log(`  ${color('blue', companyName)} | ${location}`);
     const fundingLine = formatFundingLine(job.company);
     if (fundingLine) console.log(`  ${color('magenta', fundingLine)}`);
-    console.log(`  ID: ${color('dim', job.id)} | Posted: ${color('dim', job.postedAt || job.firstSeenAt || 'unknown')}`);
+    const date = jobDatePresentation(job);
+    const requirement = sourceRequirement(job);
+    const requirementText = requirement ? ` | Req: ${color('dim', requirement)}` : '';
+    console.log(`  ID: ${color('dim', job.id)} | ${date.label}: ${color('dim', date.value)}${requirementText}`);
     if (job.jobUrl) console.log(`  ${color('dim', job.jobUrl)}`);
     console.log();
   }
@@ -330,4 +434,4 @@ function outputError(msg) {
   console.error(color('red', `Error: ${msg}`, process.stderr));
 }
 
-module.exports = { color, shouldColor, isJSON, outputJobs, outputCompanies, outputStats, outputContacts, outputReferralCampaign, outputNetworkBrief, outputCompanyBrief, outputCompanyWorkspace, outputError };
+module.exports = { color, shouldColor, isJSON, jobDatePresentation, jobDateDetailLines, outputJobs, outputCompanies, outputStats, outputContacts, outputReferralCampaign, outputNetworkBrief, outputCompanyBrief, outputCompanyWorkspace, outputError };

package/mcp/apply-tools.js

@@ -18,7 +18,6 @@ const APPLY_BROWSER_SURFACES = APPLY_CONTRACT.constants.applyBrowserSurfaces;
 const APPLY_EXECUTION_ACCESS_CLASSIFICATIONS = APPLY_CONTRACT.constants.applyAccessClassifications;
 const APPLY_EXECUTION_DISPOSITION_SOURCES = APPLY_CONTRACT.constants.applyExecutionDispositionSources;
 const APPLY_SCENARIO_CODES = APPLY_CONTRACT.constants.applyScenarioCodes;
-const APPLY_CHECKPOINT_ACTION_CODES = APPLY_CONTRACT.constants.applyCheckpointActionCodes;
 const APPLY_EXECUTION_MAX_TARGET = APPLY_CONTRACT.constants.applyExecutionMaxTarget;
 const APPLY_EXECUTION_STOP_REASON_CODES = APPLY_CONTRACT.constants.applyExecutionStopReasonCodes;
 const FIXED_APPLY_BATCH_CANCEL_REASON_CODES = APPLY_CONTRACT.constants.fixedApplyBatchCancelReasonCodes;
@@ -35,8 +34,96 @@ const APPLY_BATCH_MAX_CHECKPOINTS_PER_REQUEST = 20;
 const APPLY_BATCH_MAX_ACTIONS_PER_CHECKPOINT = 25;
 const APPLY_BATCH_MAX_BULK_MUTATIONS = 20;
 
+const APPLY_CHECKPOINT_CONTINUATION_BY_ACTION = APPLY_CONTRACT.constants
+  .applyCheckpointContinuationByAction;
+const APPLY_CHECKPOINT_LIFECYCLE_BY_ACTION = APPLY_CONTRACT.constants
+  .applyCheckpointLifecycleByAction;
+const APPLY_CHECKPOINT_QUESTION_PACKET_BY_ACTION = APPLY_CONTRACT.constants
+  .applyCheckpointQuestionPacketByAction;
+const APPLY_CHECKPOINT_ACTION_CODES = APPLY_CONTRACT.constants.applyCheckpointActionCodes;
+const applyCheckpointActionVariant = (actionCode) => z.object({
+  actionCode: z.literal(actionCode),
+  continuationAllowed: z.literal(APPLY_CHECKPOINT_CONTINUATION_BY_ACTION[actionCode]),
+  fieldFingerprint: APPLY_CHECKPOINT_QUESTION_PACKET_BY_ACTION[actionCode]
+    ? z.string().regex(/^[a-f0-9]{64}$/)
+    : z.string().regex(/^[a-f0-9]{64}$/).optional(),
+});
+const applyCheckpointActionSchema = z.discriminatedUnion(
+  'actionCode',
+  APPLY_CHECKPOINT_ACTION_CODES.map(applyCheckpointActionVariant),
+);
+
 const SAFE_OBSERVATION_CODE = /^[a-z0-9][a-z0-9_:-]{0,99}$/;
 const SAFE_IDEMPOTENCY_KEY = /^[\x20-\x7e]+$/;
+const applyCheckpointSchema = z.object({
+  memberId: z.number().int().min(1),
+  runId: z.number().int().min(1),
+  expectedMemberVersion: z.number().int().min(1),
+  expectedInspectionEpoch: z.number().int().min(0),
+  inspectionEpoch: z.number().int().min(0),
+  packetPhase: z.enum(APPLY_CHECKPOINT_PACKET_PHASES).optional(),
+  knownFieldsCommitted: z.boolean(),
+  resolvedActionIds: z.array(z.string().regex(/^[1-9][0-9]*$/))
+    .max(APPLY_BATCH_MAX_ACTIONS_PER_CHECKPOINT).optional(),
+  idempotencyKey: z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY),
+  actions: z.array(applyCheckpointActionSchema)
+    .min(1).max(APPLY_BATCH_MAX_ACTIONS_PER_CHECKPOINT),
+}).superRefine((checkpoint, context) => {
+  if (checkpoint.inspectionEpoch !== checkpoint.expectedInspectionEpoch) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['inspectionEpoch'],
+      message: 'inspectionEpoch must equal expectedInspectionEpoch',
+    });
+  }
+  if (checkpoint.resolvedActionIds
+    && new Set(checkpoint.resolvedActionIds).size !== checkpoint.resolvedActionIds.length) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['resolvedActionIds'],
+      message: 'resolvedActionIds must be unique',
+    });
+  }
+  const actionCodes = checkpoint.actions.map(({ actionCode }) => actionCode);
+  if (new Set(actionCodes.map((code) => APPLY_CHECKPOINT_LIFECYCLE_BY_ACTION[code])).size !== 1) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['actions'],
+      message: 'Actions in one inspection checkpoint must share one lifecycle',
+    });
+  }
+  const hasQuestions = actionCodes.some((code) => APPLY_CHECKPOINT_QUESTION_PACKET_BY_ACTION[code]);
+  if (hasQuestions && checkpoint.packetPhase === undefined) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['packetPhase'],
+      message: 'Question checkpoints require a packet phase',
+    });
+  }
+  if (hasQuestions && !checkpoint.knownFieldsCommitted) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['knownFieldsCommitted'],
+      message: 'Question checkpoints require committed known fields',
+    });
+  }
+  if (!hasQuestions && checkpoint.packetPhase !== undefined) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['packetPhase'],
+      message: 'packetPhase is only valid for grouped questions',
+    });
+  }
+  const reviewReady = actionCodes.includes('captcha/at_submit')
+    || actionCodes.includes('review/manual_submit');
+  if (reviewReady && !checkpoint.knownFieldsCommitted) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['knownFieldsCommitted'],
+      message: 'Review checkpoints require all known fields to be committed',
+    });
+  }
+});
 const iso3166Alpha2Schema = z.string().regex(/^[A-Za-z]{2}$/).refine(isIso3166Alpha2, {
   message: 'Expected an ISO 3166-1 alpha-2 country code',
 });
@@ -263,7 +350,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.1 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. Every checkpoint action must use its canonical continuationAllowed value; review/manual_submit, captcha/at_submit, trust/origin_mismatch, and observability/unverifiable_state require false. Fail closed on a rejected 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,
@@ -773,25 +860,10 @@ function registerApplyTools(
     {
       batchId: z.number().int().min(1),
       leaseToken: z.string().min(1).max(1024),
-      checkpoints: z.array(z.object({
-        memberId: z.number().int().min(1),
-        runId: z.number().int().min(1),
-        expectedMemberVersion: z.number().int().min(1),
-        expectedInspectionEpoch: z.number().int().min(0),
-        inspectionEpoch: z.number().int().min(0),
-        packetPhase: z.enum(APPLY_CHECKPOINT_PACKET_PHASES).optional(),
-        knownFieldsCommitted: z.boolean(),
-        resolvedActionIds: z.array(z.string().regex(/^[1-9][0-9]*$/))
-          .max(APPLY_BATCH_MAX_ACTIONS_PER_CHECKPOINT).optional(),
-        idempotencyKey: z.string().min(16).max(200).regex(SAFE_IDEMPOTENCY_KEY),
-        actions: z.array(z.object({
-          actionCode: z.enum(APPLY_CHECKPOINT_ACTION_CODES),
-          continuationAllowed: z.boolean(),
-          fieldFingerprint: z.string().regex(/^[a-f0-9]{64}$/).optional(),
-        })).min(1).max(APPLY_BATCH_MAX_ACTIONS_PER_CHECKPOINT),
-      })).min(1).max(APPLY_BATCH_MAX_CHECKPOINTS_PER_REQUEST),
+      checkpoints: z.array(applyCheckpointSchema)
+        .min(1).max(APPLY_BATCH_MAX_CHECKPOINTS_PER_REQUEST),
     },
-    wrapTool(async ({ batchId, ...body }) => apiRequest(
+    wrapTool(async ({ batchId, ...body }) => applyApiRequest(
       'POST',
       `/api/jobscout/apply/batches/${batchId}/checkpoints`,
       body,
@@ -1199,7 +1271,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.1 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 +1279,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.6 and skill 4.7.1. 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.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "trackly-cli",
-      "version": "0.16.0",
+      "version": "0.17.1",
       "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.1",
   "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.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "trackly-cli",
-      "version": "0.16.0",
+      "version": "0.17.1",
       "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.1 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.1. 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.
@@ -118,13 +125,15 @@ Follow this order:
 5. Use real UI clicks for React/native selects, radios, and checkboxes. Resolve boolean values by their exact semantic label (`true` to Yes, `false` to No), never by option order, index, proximity, or a stale prior selection. After every selection, compare the committed value with the canonical Trackly value. If the field is required or had a validation error before selection, verify that the required-field error disappeared. An optional control with no validation error passes when its committed value is correct. Treat any value mismatch or applicable stale error as a failed field and correct it before continuing.
 6. Recheck email and phone through both browser DOM state and macOS accessibility state. Require exact values and reject duplicate/concatenated values.
 7. Complete every visible field whose canonical answer is known, including optional fields, previous-employer/title history, education rows and dates, links, relocation, communication preferences, and opportunity source. Before review, compare the live field inventory with the resolved Trackly profile and prove that no known visible answer was silently omitted. Group only genuinely unknown contextual fields into the question packet.
+   - Before asking, query the typed scopes in [references/answer-resolution.md](references/answer-resolution.md) from narrowest to broadest and retain only value-free counts and fingerprints. Semantic similarity may find a canonical intent candidate but never supplies an answer.
+   - Account for every visible control with exactly one typed disposition and validate the `fill` receipt. Reconcile all canonical education records and position-level employment records, then audit every resume stage separately. Aggregate counts or a successful upload call alone are not completeness proof.
    - Enter education and employment-history rows in reverse chronological order, with the most recent or current record first.
    - Keep employment status, current company, and most recent employer distinct. An intentionally blank current company remains blank and never implies an employment status; read employment status independently from its canonical profile field or ask once. The blank also does not erase prior employment. For “most recent employer/title,” use `employment.most_recent_company` and `employment.most_recent_title` only after the fetched profile schema exposes those exact keys. If an exposed key is unknown, ask once and sync the confirmed value globally through `trackly_update_application_profile` instead of inserting the current-company blank or inventing an employer. If either key is absent from the fetched schema, do not PATCH it; preserve the answer locally for the current form and report that the backend schema must update.
    - 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.
-10. Run the full integrity gate, including the final consent checkbox, every visible error, all steps, and any correction banner.
+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. Reinventory after conditional reveals and require the final form-inventory fingerprint to cover the exact current surface.
 
 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.
 
@@ -148,7 +157,7 @@ the sole active receipt returned by Trackly; if multiple receipts remain, ask
 the user to identify the intended group. Never guess a receipt from tabs or
 chat history.
 
-After every conditional field is settled and all other review gates pass, bulk checkpoint every ready member with `review/manual_submit`, the current unchanged inspection epoch in both epoch fields, and any `resolvedActionIds`. Use the returned member versions and epochs; this checkpoint resolves the listed human actions and moves the durable member lifecycle to `review_ready` without invalidating current-epoch browser evidence or an unchanged resume-content approval. Do not wait for `needs_input` members: whenever at least one member is durably `review_ready`, ask for one explicit final truthfulness confirmation for the exact complete subset that is currently `review_ready`. If any form in that certified subset used a resume attachment, certify with `resumeDependency: approved` and the exact approved resume identity. If no form in the subset exposes a resume control, certify with `resumeDependency: not_applicable` and omit the resume ID and hash; do not invent an upload requirement. Then call `trackly_record_application_outcomes` once with every member in that certified subset using its exact current `runId`, `batchId`, `memberId`, `inspectionEpoch`, and `leaseToken`; every item must use the literal `outcome: review_ready`. Verify every recorded run returns `awaiting_manual_submit` before showing the review handoff. A member conflict does not invalidate successful siblings: preserve its tab, refresh that member once, and surface the returned stable conflict code instead of blindly replaying a different transition. A member that becomes ready later requires a fresh certification for the then-current complete `review_ready` subset; never reuse an older certification for it. Use singular `trackly_record_application_outcome` only for a legacy single run or an isolated post-review transition. Use the normal review block in [references/review-handoff.md](references/review-handoff.md) only after documented visibility proof for the exact review tab succeeds. If visibility is unverified, preserve the tab, use the separate visibility-unverified block, and do not tell the user to submit until the tab is reclaimed and visibly proven. For a single run, keep the browser on the final review state and stop. For a frozen batch, preserve every review-ready tab, hand off each certified review-ready subset without waiting on unrelated human actions, and continue the same lifecycle for the remaining mapped members. Members with unresolved actions stay frozen and resumable. Never submit any member. End with job ID -> run ID -> browser tab -> ATS -> status plus the actual scenario coverage for each run.
+After every conditional field is settled and all other review gates pass, bulk checkpoint every ready member with `review/manual_submit`, literal `continuationAllowed: false`, the current unchanged inspection epoch in both epoch fields, and any `resolvedActionIds`. Preserve the accepted checkpoint response and use its returned member versions and epochs; this checkpoint resolves the listed human actions and moves the durable member lifecycle to `review_ready` without invalidating current-epoch browser evidence or an unchanged resume-content approval. On `Apply checkpoint action fields are invalid` or another schema rejection, refetch once and fail closed unless the current public contract proves an exact compatible payload. Never retry a malformed payload or claim durable readiness. Do not wait for `needs_input` members: whenever at least one member is durably `review_ready`, ask for one explicit final truthfulness confirmation for the exact complete subset that is currently `review_ready`. If any form in that certified subset used a resume attachment, certify with `resumeDependency: approved` and the exact approved resume identity. If no form in the subset exposes a resume control, certify with `resumeDependency: not_applicable` and omit the resume ID and hash; do not invent an upload requirement. After that confirmation is recorded, validate the value-free review receipt against the preserved accepted checkpoint response and current visibility proof; include the resolved-action count and fingerprint, never the raw IDs. Then call `trackly_record_application_outcomes` once with every member in that certified subset using its exact current `runId`, `batchId`, `memberId`, `inspectionEpoch`, and `leaseToken`; every item must use the literal `outcome: review_ready`. Verify every recorded run returns `awaiting_manual_submit` before showing the review handoff. A member conflict does not invalidate successful siblings: preserve its tab, refresh that member once, and surface the returned stable conflict code instead of blindly replaying a different transition. A member that becomes ready later requires a fresh certification for the then-current complete `review_ready` subset; never reuse an older certification for it. Use singular `trackly_record_application_outcome` only for a legacy single run or an isolated post-review transition. Use the normal review block in [references/review-handoff.md](references/review-handoff.md) only after documented visibility proof for the exact review tab succeeds. Always validate a `handoff` receipt that reports employer, Trackly, and browser state separately. If visibility is unverified, preserve the tab, set `reviewReadyClaimed: false`, use the separate visibility-unverified block, and do not tell the user to submit until the tab is reclaimed and visibly proven. For a single run, keep the browser on the final review state and stop. For a frozen batch, preserve every review-ready tab, hand off each certified review-ready subset without waiting on unrelated human actions, and continue the same lifecycle for the remaining mapped members. Members with unresolved actions stay frozen and resumable. Never submit any member. End with job ID -> run ID -> browser tab -> ATS -> status plus the actual scenario coverage for each run.
 
 After the user submits manually:
 

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.