fix(apply): accept safe page-model options

Author: CharGrnmn

batch/codex-apply-one.prompt.md

@@ -186,7 +186,7 @@ dispatch, or any other denial is terminal.
     Write required narrative answers in the candidate's plain, specific voice
     using only `cv.md`, the report, and the facts file. If a required field
     cannot be answered truthfully, stop before Submit.
-11. Build one immutable actions array matching the installed Geometra 1.65.6
+11. Build one immutable actions array matching the installed Geometra 1.65.7
     schema exactly. Do not use obsolete `valuesByLabel`, nested `target`, or
     `labelOrText` properties. Use this shape:
 
@@ -279,7 +279,7 @@ dispatch, or any other denial is terminal.
 12. Execute one logical `geometra_run_actions` transaction using the owned
     session ID, `softTimeoutMs: 45000`, `output: "full"`,
     `includeSteps: true`, and the immutable actions array. Do not use the
-    compact batched fill path: Geometra 1.65.6 can abort the whole grouped text
+    compact batched fill path: Geometra 1.65.7 can abort the whole grouped text
     action there without identifying the field, while the sequential in-call
     path is stable and preserves exact-once submission. If it returns a soft
     pause with `resumeFromIndex`, continuation is allowed only with the same

bin/geometra-mcp-launcher.mjs

@@ -5,7 +5,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-const DEFAULT_FALLBACK_PACKAGE = '@geometra/mcp@1.65.6';
+const DEFAULT_FALLBACK_PACKAGE = '@geometra/mcp@1.65.7';
 const RESOLVE_ONLY_FLAG = '--job-forge-resolve-target';
 const DEFAULT_LOG_RELATIVE_PATH = '.jobforge-mcp/geometra-mcp.jsonl';
 const DEFAULT_HEARTBEAT_MS = 15_000;

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "job-forge",
-  "version": "2.14.70",
+  "version": "2.14.71",
   "description": "AI-powered job search pipeline for Codex and OpenCode",
   "type": "module",
   "bin": {
@@ -219,7 +219,7 @@
     "@agent-pattern-labs/iso-score": "^0.1.2",
     "@agent-pattern-labs/iso-timeline": "^0.1.2",
     "@agent-pattern-labs/iso-trace": "^0.5.2",
-    "@geometra/mcp": "1.65.6",
+    "@geometra/mcp": "1.65.7",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@razroo/gmail-mcp": "1.8.1",
     "playwright": "1.61.1",

package.json

@@ -103,6 +103,16 @@ const RECOVERABLE_CONTROL_DENIAL = 'Tool update_plan is outside the live-applica
 const RECOVERABLE_PRE_SUBMIT_QUERY_DENIAL = 'Geometra query is limited to one exact zero-form Application-tab discovery or bounded post-submit evidence.';
 const RECOVERABLE_PRE_SCHEMA_RUN_ACTIONS_DENIAL = 'Geometra run_actions requires successful parsed connect, page-model, and form-schema responses.';
 const RECOVERABLE_PRE_NAVIGATION_FORM_SCHEMA_DENIAL = 'Geometra form schema requires parsed page-model form evidence or one proven application-navigation click.';
+const PAGE_MODEL_INPUT_DENIAL_CATEGORY = 'geometra-page-model-input';
+const PAGE_MODEL_INPUT_KEYS = [
+  'sessionId',
+  'maxPrimaryActions',
+  'maxSectionsPerKind',
+  'includeScreenshot',
+  'blockDetection',
+  'blockedSitePolicy',
+  'manualHandoff',
+];
 const PATH_VALUE_OPTIONS = new Set([
   '--input',
   '--output',
@@ -239,12 +249,21 @@ export function evaluateApplyWorkerToolCall(input, currentState = initialGuardSt
     decision = deny(`Tool ${toolName || '(unknown)'} is outside the live-application allowlist.`);
   }
 
-  state.events.push({ tool: toolName || '(unknown)', decision: decision.allow ? 'allow' : 'deny' });
+  const event = { tool: toolName || '(unknown)', decision: decision.allow ? 'allow' : 'deny' };
+  if (!decision.allow && decision.denialCategory) {
+    event.denialCategory = decision.denialCategory;
+    event.inputKeys = [...decision.inputKeys];
+  }
+  state.events.push(event);
   if (!decision.allow) {
     const denial = {
       tool: toolName || '(unknown)',
       reason: decision.reason,
       eventIndex: state.events.length - 1,
+      ...(decision.denialCategory ? {
+        denialCategory: decision.denialCategory,
+        inputKeys: [...decision.inputKeys],
+      } : {}),
     };
     if (isRecoverableGuardDenial(toolName, toolInput, decision, state)) {
       state.recoverableDenials.push(denial);
@@ -422,11 +441,8 @@ function evaluateGeometra(tool, args, state) {
     if (!session.allow) return session;
     if (tool === 'geometra_page_model') {
       if (state.pageModelCalls !== 0) return deny('Only one Geometra page-model call is allowed before submission.');
-      if (args.blockDetection !== true
-        || args.blockedSitePolicy !== 'manual-handoff'
-        || !hasOnlyKeys(args, ['sessionId', 'blockDetection', 'blockedSitePolicy'])) {
-        return deny('Geometra page model requires only the owned session with block detection and manual handoff enforced.');
-      }
+      const inputDecision = evaluatePageModelInput(args);
+      if (!inputDecision.allow) return inputDecision;
       state.pageModelBlockDetectionEnforced = true;
       state.pageModelCalls += 1;
     }
@@ -1335,6 +1351,50 @@ function hasOnlyKeys(value, allowedKeys) {
   return Object.keys(value || {}).every((key) => allowed.has(key));
 }
 
+function evaluatePageModelInput(args) {
+  if (!hasOnlyKeys(args, PAGE_MODEL_INPUT_KEYS)) {
+    return denyPageModelInput('Geometra page model contains fields outside the supported safe schema.', args);
+  }
+  if (args.blockDetection !== true) {
+    return denyPageModelInput('Geometra page model requires blockDetection=true.', args);
+  }
+  if (args.blockedSitePolicy !== 'manual-handoff') {
+    return denyPageModelInput('Geometra page model requires blockedSitePolicy="manual-handoff".', args);
+  }
+  if (args.includeScreenshot !== undefined && args.includeScreenshot !== false) {
+    return denyPageModelInput('Geometra page model screenshots must be omitted or disabled.', args);
+  }
+  if (args.manualHandoff !== undefined && typeof args.manualHandoff !== 'boolean') {
+    return denyPageModelInput('Geometra page model manualHandoff must be boolean when provided.', args);
+  }
+  if (args.maxPrimaryActions !== undefined
+    && (!Number.isInteger(args.maxPrimaryActions)
+      || args.maxPrimaryActions < 1
+      || args.maxPrimaryActions > 12)) {
+    return denyPageModelInput('Geometra page model maxPrimaryActions must be an integer from 1 through 12.', args);
+  }
+  if (args.maxSectionsPerKind !== undefined
+    && (!Number.isInteger(args.maxSectionsPerKind)
+      || args.maxSectionsPerKind < 1
+      || args.maxSectionsPerKind > 16)) {
+    return denyPageModelInput('Geometra page model maxSectionsPerKind must be an integer from 1 through 16.', args);
+  }
+  return allow();
+}
+
+function denyPageModelInput(reason, args) {
+  return deny(reason, {
+    denialCategory: PAGE_MODEL_INPUT_DENIAL_CATEGORY,
+    inputKeys: safeDiagnosticInputKeys(args),
+  });
+}
+
+function safeDiagnosticInputKeys(value) {
+  return [...new Set(Object.keys(value || {}).map((key) => (
+    /^[A-Za-z][A-Za-z0-9_]{0,63}$/.test(key) ? key : '[redacted-key]'
+  )))].sort();
+}
+
 function jobIdFromUrl(value) {
   try {
     return new URL(value).pathname.split('/').filter(Boolean).at(-1) || '';
@@ -1797,8 +1857,8 @@ function allow() {
   return { allow: true, reason: null };
 }
 
-function deny(reason) {
-  return { allow: false, reason };
+function deny(reason, diagnostics = {}) {
+  return { allow: false, reason, ...diagnostics };
 }
 
 function parseStatePath(argv) {

scripts/apply-worker-guard.mjs

@@ -416,29 +416,65 @@ test('malformed connect responses retain independent block evidence', () => {
   }
 });
 
-test('page-model discovery requires the exact block-detecting request', () => {
+test('page-model discovery accepts the safe Geometra schema and expanded defaults', () => {
   for (const toolInput of [
-    { sessionId: 'session-1' },
-    { ...pageModelInput, blockDetection: false },
-    { ...pageModelInput, blockedSitePolicy: 'continue' },
-    { ...pageModelInput, includeScreenshot: false },
+    pageModelInput,
+    {
+      ...pageModelInput,
+      maxPrimaryActions: 6,
+      maxSectionsPerKind: 8,
+      includeScreenshot: false,
+      manualHandoff: false,
+    },
+    {
+      ...pageModelInput,
+      maxPrimaryActions: 12,
+      maxSectionsPerKind: 16,
+      includeScreenshot: false,
+      manualHandoff: true,
+    },
   ]) {
     const result = evaluateApplyWorkerToolCall({
       tool_name: 'mcp__geometra__geometra_page_model',
       tool_input: toolInput,
     }, successfulConnect(initialGuardState(JOB_URL, PROJECT_ROOT)));
-    assert.equal(result.allow, false, JSON.stringify(toolInput));
-    assert.equal(result.state.pageModelCalls, 0, JSON.stringify(toolInput));
-    assert.equal(result.state.pageModelBlockDetectionEnforced, false, JSON.stringify(toolInput));
+    assert.equal(result.allow, true, result.reason);
+    assert.equal(result.state.pageModelCalls, 1);
+    assert.equal(result.state.pageModelBlockDetectionEnforced, true);
   }
+});
 
-  const allowed = evaluateApplyWorkerToolCall({
-    tool_name: 'mcp__geometra__geometra_page_model',
-    tool_input: pageModelInput,
-  }, successfulConnect(initialGuardState(JOB_URL, PROJECT_ROOT)));
-  assert.equal(allowed.allow, true, allowed.reason);
-  assert.equal(allowed.state.pageModelCalls, 1);
-  assert.equal(allowed.state.pageModelBlockDetectionEnforced, true);
+test('page-model discovery rejects unsafe schema values with value-free diagnostics', () => {
+  for (const [label, toolInput] of [
+    ['missing block detection', { sessionId: 'session-1', blockedSitePolicy: 'manual-handoff' }],
+    ['disabled block detection', { ...pageModelInput, blockDetection: false }],
+    ['wrong blocked-site policy', { ...pageModelInput, blockedSitePolicy: 'continue' }],
+    ['enabled screenshot', { ...pageModelInput, includeScreenshot: true }],
+    ['non-boolean screenshot', { ...pageModelInput, includeScreenshot: 'false' }],
+    ['non-boolean handoff', { ...pageModelInput, manualHandoff: 'false' }],
+    ['primary cap below range', { ...pageModelInput, maxPrimaryActions: 0 }],
+    ['primary cap above range', { ...pageModelInput, maxPrimaryActions: 13 }],
+    ['primary cap non-integer', { ...pageModelInput, maxPrimaryActions: 1.5 }],
+    ['section cap below range', { ...pageModelInput, maxSectionsPerKind: 0 }],
+    ['section cap above range', { ...pageModelInput, maxSectionsPerKind: 17 }],
+    ['section cap non-integer', { ...pageModelInput, maxSectionsPerKind: 1.5 }],
+    ['unknown key', { ...pageModelInput, unsupportedOption: 'sensitive-value' }],
+  ]) {
+    const result = evaluateApplyWorkerToolCall({
+      tool_name: 'mcp__geometra__geometra_page_model',
+      tool_input: toolInput,
+    }, successfulConnect(initialGuardState(JOB_URL, PROJECT_ROOT)));
+    const expectedKeys = Object.keys(toolInput).sort();
+    assert.equal(result.allow, false, label);
+    assert.equal(result.state.pageModelCalls, 0, label);
+    assert.equal(result.state.pageModelBlockDetectionEnforced, false, label);
+    assert.equal(result.state.violations.length, 1, label);
+    assert.equal(result.state.violations[0].denialCategory, 'geometra-page-model-input', label);
+    assert.deepEqual(result.state.violations[0].inputKeys, expectedKeys, label);
+    assert.equal(result.state.events.at(-1).denialCategory, 'geometra-page-model-input', label);
+    assert.deepEqual(result.state.events.at(-1).inputKeys, expectedKeys, label);
+    assert.equal(JSON.stringify(result.state).includes('sensitive-value'), false, label);
+  }
 });
 
 test('page-model and form-schema capabilities unlock only after successful structured responses', () => {

test/apply-worker-guard.test.mjs

@@ -7,8 +7,6 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import test from 'node:test';
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const GEOMETRA_VERSION = '1.65.6';
-
 async function readJson(path) {
   return JSON.parse(await readFile(path, 'utf8'));
 }
@@ -20,15 +18,16 @@ test('JobForge pins and resolves the released Geometra dependency chain', async
   const installedProxy = await readJson(join(ROOT, 'node_modules/@geometra/proxy/package.json'));
   const launcher = await readFile(join(ROOT, 'bin/geometra-mcp-launcher.mjs'), 'utf8');
   const prompt = await readFile(join(ROOT, 'batch/codex-apply-one.prompt.md'), 'utf8');
+  const geometraVersion = pkg.dependencies['@geometra/mcp'];
 
-  assert.equal(pkg.dependencies['@geometra/mcp'], GEOMETRA_VERSION);
-  assert.equal(lock.packages[''].dependencies['@geometra/mcp'], GEOMETRA_VERSION);
-  assert.equal(lock.packages['node_modules/@geometra/mcp'].version, GEOMETRA_VERSION);
-  assert.equal(lock.packages['node_modules/@geometra/proxy'].version, GEOMETRA_VERSION);
-  assert.equal(installedMcp.version, GEOMETRA_VERSION);
-  assert.equal(installedProxy.version, GEOMETRA_VERSION);
-  assert.ok(launcher.includes(`@geometra/mcp@${GEOMETRA_VERSION}`));
-  assert.ok(prompt.includes(`installed Geometra ${GEOMETRA_VERSION}`));
+  assert.match(geometraVersion, /^\d+\.\d+\.\d+$/);
+  assert.equal(lock.packages[''].dependencies['@geometra/mcp'], geometraVersion);
+  assert.equal(lock.packages['node_modules/@geometra/mcp'].version, geometraVersion);
+  assert.equal(lock.packages['node_modules/@geometra/proxy'].version, geometraVersion);
+  assert.equal(installedMcp.version, geometraVersion);
+  assert.equal(installedProxy.version, geometraVersion);
+  assert.ok(launcher.includes(`@geometra/mcp@${geometraVersion}`));
+  assert.ok(prompt.includes(`installed Geometra ${geometraVersion}`));
 
   const result = spawnSync(
     process.execPath,
@@ -43,7 +42,7 @@ test('JobForge pins and resolves the released Geometra dependency chain', async
     assert.equal(target.resolvedPath, siblingPath);
   } else {
     assert.equal(target.source, 'npm-package');
-    assert.equal(target.packageSpec, `@geometra/mcp@${GEOMETRA_VERSION}`);
+    assert.equal(target.packageSpec, `@geometra/mcp@${geometraVersion}`);
   }
 });