trackly-cli 0.17.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.7.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.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.';
+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.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.' },
+      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.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.',
+        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.17.0",
+  "version": "0.17.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "trackly-cli",
-      "version": "0.17.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.17.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.17.0",
+  "version": "0.17.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "trackly-cli",
-      "version": "0.17.0",
+      "version": "0.17.1",
       "runtimeHint": "npx",
       "runtimeArguments": [
         {

package/skills/trackly-apply/SKILL.md

@@ -35,7 +35,7 @@ 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.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.
+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.
@@ -80,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.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.
+   - 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.
@@ -125,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, 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.
+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.
 
@@ -155,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/answer-resolution.md

@@ -32,6 +32,23 @@ revision, schema key, scope, authority class, derivation rule when any,
 expected type, and committed-control receipt. Never send the answer value in
 an observation.
 
+## Typed answer-memory lookup
+
+Before asking, query every applicable scope in this narrow-to-broad order:
+run-only live choice, exact question and version, exact office, jurisdiction,
+company, provider, then global. A candidate is reusable only when its canonical
+intent, type, sensitivity, question version when applicable, and permitted
+scope all match. The first compatible narrower answer wins; an answer never
+flows to a broader scope without explicit user confirmation.
+
+Question-ontology aliases, semantic retrieval, and form-schema history may
+identify candidate canonical intents, but they are not answer authority. Exact
+typed profile or contextual state must still resolve the value. Fail closed to
+`missing_fact`, `live_consent`, or `forbidden_inference` when intent, type,
+scope, version, or confidence is ambiguous. Record only per-scope counts and a
+lowercase SHA-256 over value-free lookup inputs and decisions; never hash or
+persist labels, answers, page text, or private values in the checkpoint.
+
 ## Source precedence
 
 The current profile revision is the only reusable answer authority. A
@@ -40,6 +57,14 @@ or cached value is never authority. Resume parsing is a suggestion only: it may
 help identify a schema key, but the parser never becomes authority and never
 overwrites an answered profile value or a user-edited control.
 
+For a frozen batch, distinguish its frozen profile revision (the audit and
+certification baseline) from the current bounded snapshot projection used to
+resolve visible answers. A later scoped answer may legitimately appear in the
+current projection while the frozen baseline number remains unchanged. Do not
+treat that difference as corruption, do not silently substitute the stale
+baseline value, and do not mutate until the current work receipt authorizes the
+projection and certification behavior.
+
 Contact details and addresses must resolve from exact current profile keys.
 Verify their live committed state even when the browser initially displays a
 masked or formatted value.

package/skills/trackly-apply/references/browser-upload.md

@@ -6,11 +6,24 @@ other.
 
 ## Capability gate
 
-Before opening a file chooser, require the active browser adapter to advertise
-all five capabilities: semantic control discovery, chooser arming, file
-attachment, committed-filename inspection, and parser-field recheck. If any is
-missing, fail closed before opening the chooser and hand the upload to the user. Never
-navigate to a `file://` URL or paste a local path into an ordinary text field.
+Before an automated upload, require the active browser adapter to advertise all
+five capabilities: semantic control discovery, chooser arming, file attachment,
+committed-filename inspection, and parser-field recheck. If only chooser arming
+or file attachment is unavailable, fail closed before opening the chooser and
+hand the upload to the user only when semantic control discovery,
+committed-filename inspection, and parser-field recheck remain available. If
+any of those three verification capabilities is unavailable, stop the fill as
+unverified; do not route it into `manual_unbound`, claim a passed audit, or
+continue to review. Never navigate to a `file://` URL or paste a local path into
+an ordinary text field.
+
+When the user performs that handoff upload, keep it explicitly manual,
+browser-local, and unbound. Record `resumeAudit.mode: manual_unbound`,
+`approval: passed`, `preAttachVerification: not_applicable`, and
+`attachmentCommit: user_confirmed` only for this genuine manual path; do not use
+those values for an agent-performed upload or a failed verifier. Before
+continuing, require `passed` filename verification and parser recheck, then
+prove during the `passed` final sweep that the attachment and filename persist.
 
 Perform these stages in exact order:
 
@@ -19,14 +32,19 @@ Perform these stages in exact order:
 3. prove the chooser opened;
 4. run `trackly_verify_prepared_resume`, then immediately attach that verified
    file through the adapter's documented file-setting primitive;
-5. verify the employer-facing filename committed; and
+5. verify the employer-facing filename committed;
 6. recheck every contact, employment, education, and other field that resume
-   parsing may have changed.
+   parsing may have changed; and
+7. during the final sweep, prove the attachment is still committed and the
+   visible filename remains the approved employer-facing filename.
 
 Pass only the value-free stage outcomes to
 `trackly_validate_apply_resume_upload`. Do not pass a filename, local path,
 resume hash, form value, URL, page text, or tab identifier. Claim attachment
-success only when it returns `safeToClaimAttachment: true`.
+success only when it returns `safeToClaimAttachment: true`. Record the six
+audited outcomes separately: approval, pre-attach verification, attachment
+commit, filename verification, parser recheck, and final-sweep persistence. A
+single upload-success boolean cannot replace this chain.
 
 Stable failure codes include capability unavailable, ambiguous control,
 chooser timeout, chooser opened without a commit, missing or expired file,