fix: harden five-host skill route sampling

Author: rockyshi1993

hooks/_runtime/host-skill-route-capabilities.v1.json

@@ -34,10 +34,10 @@
       "status": "PASS",
       "testedVersion": "grok 0.2.112 (9bbd559437)",
       "protocol": "MCP 2024-11-05",
-      "runtimeContractDigest": "a9772e7f30b2b40f72c16f70ffbcb82844d5a59546b0bdf6a3068eda53794141",
+      "runtimeContractDigest": "2eb23345d426d870b2f45f0c585bc341c87c110612d357efaa79d39c14af3489",
       "hostAdapterDigest": "b2ab490df9c881a1a8b67c8391f72c615d05a64aab1db9e4bd6ec8a5f0a99385",
-      "evidenceDigest": "667c4481e6cc2634c67a276b724306ae2c77170b10dbf41ca20d18832a6766f4",
-      "evidenceRef": "E:/Worker/.devcodex/devcodex/.audit-state/skill-route-s15-grok-20260729-final-production.json",
+      "evidenceDigest": "771a886ffc0606ac08429fa4e27675422083b864df76e2d1c43819fac7333c95",
+      "evidenceRef": "E:/Worker/.devcodex/devcodex/.audit-state/skill-route-s15-grok-20260729-current-candidate.json",
       "entrySurface": "devcodex grok -p/--single",
       "bootstrapDelivery": "global launcher --rules",
       "defaultEligible": true

hooks/_runtime/lifecycle-bootstrap-state.cjs

@@ -15,6 +15,7 @@ function parseContextToolIdentity (rawName, explicitServer = '') {
   const mcp = lower.match(/^mcp__(.+)__([a-z0-9_]+)$/)
   const doubleUnderscore = lower.match(/^([^_]+(?:-[^_]+)*)__([a-z0-9_]+)$/)
   const pair = lower.match(/^([^/]+)\/([a-z0-9_]+)$/)
+  const copilotFlat = lower.match(/^(devcodex-(?:profile|memory))-([a-z0-9_]+)$/)
   if (mcp) {
     server = mcp[1]
     tool = mcp[2]
@@ -24,6 +25,9 @@ function parseContextToolIdentity (rawName, explicitServer = '') {
   } else if (pair) {
     server = pair[1]
     tool = pair[2]
+  } else if (copilotFlat) {
+    server = copilotFlat[1]
+    tool = copilotFlat[2]
   }
   if (server === 'devcodex_profile') server = 'devcodex-profile'
   if (server === 'devcodex_memory') server = 'devcodex-memory'
@@ -350,9 +354,13 @@ function buildLifecycleBootstrapStateUtils(ctx) {
       /^ctx-[A-Za-z0-9-]{8,251}$/.test(String(env.DEVCODEX_CONTEXT_EPOCH || ''))
       ? String(env.DEVCODEX_CONTEXT_EPOCH)
       : ''
+    const adapterEpoch = env?.DEVCODEX_CONTEXT_EPOCH_SOURCE === 'host-adapter-cli' &&
+      /^ctx-[A-Za-z0-9-]{8,251}$/.test(String(env.DEVCODEX_CONTEXT_EPOCH || ''))
+      ? String(env.DEVCODEX_CONTEXT_EPOCH)
+      : ''
     state.contextAcquisition = {
       schemaVersion: CONTEXT_READ_CONTRACT.schemas.state,
-      contextEpoch: launcherEpoch || `ctx-${crypto.randomUUID()}`,
+      contextEpoch: launcherEpoch || adapterEpoch || `ctx-${crypto.randomUUID()}`,
       activeRoot: normalizePath(getActiveNamespaceRoot(state)),
       project,
       targetResolved,

hooks/_runtime/lifecycle-host-adapters.cjs

@@ -3,6 +3,7 @@
 
 const fs = require('fs')
 const path = require('path')
+const crypto = require('crypto')
 const { spawnSync } = require('child_process')
 
 const CLAUDE_EVENT_MAP = Object.freeze({
@@ -89,13 +90,81 @@ function adapterTracePath(env = process.env) {
   return target
 }
 
+function lifecycleStateTraceSummary(env = process.env) {
+  const workspaceRoot = String(env.DEVCODEX_WORKSPACE_ROOT || '').trim()
+  if (!workspaceRoot) return null
+  const namespaceRoot = path.join(path.resolve(workspaceRoot), '.devcodex')
+  if (!fs.existsSync(namespaceRoot)) return null
+  const candidates = []
+  for (const projectEntry of fs.readdirSync(namespaceRoot, { withFileTypes: true }).slice(0, 32)) {
+    if (!projectEntry.isDirectory()) continue
+    const hooksRoot = path.join(namespaceRoot, projectEntry.name, '.memory', 'hooks')
+    if (!fs.existsSync(hooksRoot)) continue
+    for (const hookEntry of fs.readdirSync(hooksRoot, { withFileTypes: true }).slice(0, 32)) {
+      if (!hookEntry.isDirectory()) continue
+      const file = path.join(hooksRoot, hookEntry.name, 'lifecycle-state.json')
+      if (fs.existsSync(file)) {
+        candidates.push({
+          file,
+          workspaceMeta: projectEntry.name.toLowerCase() === 'workspace'
+        })
+      }
+    }
+  }
+  if (!candidates.length) return null
+  const expectedEpoch = String(env.DEVCODEX_CONTEXT_EPOCH || '').trim()
+  const parsedCandidates = candidates.map(candidate => ({
+    ...candidate,
+    state: JSON.parse(fs.readFileSync(candidate.file, 'utf8')),
+    mtimeMs: fs.statSync(candidate.file).mtimeMs
+  }))
+  const selected = parsedCandidates.sort((left, right) => {
+    const leftEpochMatch = left.state.contextAcquisition?.contextEpoch === expectedEpoch ? 1 : 0
+    const rightEpochMatch = right.state.contextAcquisition?.contextEpoch === expectedEpoch ? 1 : 0
+    if (leftEpochMatch !== rightEpochMatch) return rightEpochMatch - leftEpochMatch
+    if (left.workspaceMeta !== right.workspaceMeta) return left.workspaceMeta ? 1 : -1
+    return right.mtimeMs - left.mtimeMs
+  })[0]
+  const file = selected.file
+  const state = selected.state
+  const acquisition = state.contextAcquisition || {}
+  const receipt = acquisition.receipt || {}
+  return {
+    file: path.relative(path.resolve(workspaceRoot), file).replace(/\\/g, '/'),
+    activeProject: state.activeProject || null,
+    project: acquisition.project || state.activeProject || null,
+    contextEpoch: acquisition.contextEpoch || null,
+    planId: acquisition.plan?.planId || null,
+    receiptStatus: receipt.status || null,
+    satisfiedSourceIds: receipt.satisfiedSourceIds || [],
+    missingSourceIds: receipt.missingSourceIds || [],
+    inFlight: (acquisition.inFlight || []).map(item => ({
+      canonical: item.canonical,
+      toolCallId: item.toolCallId
+    })),
+    postHistory: (acquisition.postHistory || []).slice(-8).map(item => ({
+      canonical: item.canonical,
+      toolCallId: item.toolCallId,
+      outcome: item.outcome
+    })),
+    lastError: acquisition.lastError || receipt.lastError || null
+  }
+}
+
 function appendAdapterTrace(host, phase, input, normalized, result, env = process.env) {
   const target = adapterTracePath(env)
   if (!target) return
   try {
     const payload = input && typeof input === 'object' && !Array.isArray(input) ? input : {}
+    const normalizedPayload = normalized?.payload &&
+      typeof normalized.payload === 'object' &&
+      !Array.isArray(normalized.payload)
+      ? normalized.payload
+      : {}
     const toolInput = payload.toolInput || payload.tool_input || payload.toolArgs || {}
     const toolResult = payload.toolResult || payload.tool_result || payload.toolResponse || payload.tool_response || {}
+    const normalizedToolInput = normalizedPayload.tool_input || normalizedPayload.toolInput || {}
+    const normalizedToolResult = normalizedPayload.tool_result || normalizedPayload.toolResult || {}
     const entry = {
       schemaVersion: 'LifecycleHostAdapterTraceV1',
       observedAt: new Date().toISOString(),
@@ -104,11 +173,23 @@ function appendAdapterTrace(host, phase, input, normalized, result, env = proces
       originalEvent: normalized?.originalEvent || null,
       mappedEvent: normalized?.mappedEvent || null,
       payloadKeys: Object.keys(payload).sort().slice(0, 64),
+      adapterCwd: process.cwd(),
+      payloadCwd: String(payload.cwd || payload.workingDirectory || ''),
+      promptPreview: String(
+        payload.prompt || payload.userPrompt || payload.user_prompt || ''
+      ).slice(0, 512),
       toolName: String(payload.toolName || payload.tool_name || ''),
       toolUseId: String(payload.toolUseId || payload.tool_use_id || ''),
+      normalizedToolCallId: String(
+        normalizedPayload.tool_call_id || normalizedPayload.toolCallId || ''
+      ),
       toolInputKeys: toolInput && typeof toolInput === 'object'
         ? Object.keys(toolInput).sort().slice(0, 64)
         : [],
+      normalizedToolInputDigest: crypto.createHash('sha256')
+        .update(JSON.stringify(stableJsonValue(normalizedToolInput)))
+        .digest('hex'),
+      normalizedToolInputPreview: JSON.stringify(stableJsonValue(normalizedToolInput)).slice(0, 1024),
       dispatchedServer: String(
         toolInput?.server || toolInput?.serverName || toolInput?.server_name || ''
       ),
@@ -118,10 +199,17 @@ function appendAdapterTrace(host, phase, input, normalized, result, env = proces
       toolResultKeys: toolResult && typeof toolResult === 'object'
         ? Object.keys(toolResult).sort().slice(0, 64)
         : [],
+      normalizedToolResultPreview: (() => {
+        const value = typeof normalizedToolResult === 'string'
+          ? normalizedToolResult
+          : JSON.stringify(normalizedToolResult)
+        return String(value || '').slice(0, 512)
+      })(),
       status: result?.status ?? null,
       outputKeys: result?.output && typeof result.output === 'object'
         ? Object.keys(result.output).sort().slice(0, 32)
-        : []
+        : [],
+      lifecycleState: phase === 'output' ? lifecycleStateTraceSummary(env) : null
     }
     fs.mkdirSync(path.dirname(target), { recursive: true })
     const prior = fs.existsSync(target)
@@ -171,6 +259,23 @@ function parseToolInputEnvelope(value) {
   }
 }
 
+function stableJsonValue(value) {
+  if (Array.isArray(value)) return value.map(stableJsonValue)
+  if (!value || typeof value !== 'object') return value
+  return Object.fromEntries(
+    Object.keys(value).sort().map(key => [key, stableJsonValue(value[key])])
+  )
+}
+
+function copilotToolCallId(payload) {
+  const material = JSON.stringify(stableJsonValue({
+    sessionId: payload.session_id || payload.sessionId || '',
+    toolName: payload.tool_name || payload.toolName || '',
+    toolInput: payload.tool_input || payload.toolInput || {}
+  }))
+  return `copilot-${crypto.createHash('sha256').update(material).digest('hex').slice(0, 32)}`
+}
+
 function normalizeGrokToolResult(value) {
   const output = value && typeof value === 'object' && !Array.isArray(value) &&
     Object.prototype.hasOwnProperty.call(value, 'output')
@@ -232,11 +337,40 @@ function normalizeHostPayload(host, payload) {
     if (normalized.sessionId && !normalized.session_id) normalized.session_id = normalized.sessionId
     if (normalized.transcriptPath && !normalized.transcript_path) normalized.transcript_path = normalized.transcriptPath
     if (normalized.stopReason && !normalized.stop_reason) normalized.stop_reason = normalized.stopReason
-    if (normalized.toolResult && !normalized.tool_result) normalized.tool_result = normalized.toolResult
-    if (originalEvent === 'userPromptTransformed' &&
-        /^Progressive Skill route is incomplete:/i.test(String(normalized.prompt || '').trim())) {
+    if (typeof normalized.tool_input === 'string') {
+      normalized.tool_input = parseToolInputEnvelope(normalized.tool_input) || normalized.tool_input
+    }
+    if (!normalized.tool_call_id && !normalized.toolCallId) {
+      normalized.tool_call_id = copilotToolCallId(normalized)
+      normalized.toolCallId = normalized.tool_call_id
+    }
+    if (normalized.toolResult && !normalized.tool_result) {
+      const result = normalized.toolResult
+      normalized.tool_result = typeof result.textResultForLlm === 'string'
+        ? {
+            success: result.resultType === 'success',
+            result: result.textResultForLlm,
+            ...(result.resultType === 'success'
+              ? {}
+              : { error: result.textResultForLlm || 'Copilot tool call failed.' })
+          }
+        : result
+    }
+    const continuationPrompts = [
+      normalized.prompt,
+      normalized.transformedPrompt,
+      normalized.transformed_prompt
+    ]
+    if ((originalEvent === 'userPromptSubmitted' ||
+         originalEvent === 'userPromptTransformed') &&
+        continuationPrompts.some(value =>
+          /^Progressive Skill route is incomplete:/i.test(String(value || '').trim())
+        )) {
       normalized.devcodex_host_continuation = true
     }
+    if (originalEvent === 'userPromptTransformed') {
+      normalized.devcodex_host_transform_only = true
+    }
   }
   if (host === 'gemini' && typeof payload?.prompt_response === 'string') normalized.response = payload.prompt_response
   return { originalEvent, mappedEvent, payload: normalized }
@@ -471,10 +605,20 @@ function runHostAdapter(host, input, options = {}) {
   }
   const lifecycle = options.lifecycle || path.join(__dirname, 'lifecycle.cjs')
   const spawn = options.spawnSync || spawnSync
+  const payloadCwd = String(input?.cwd || input?.workingDirectory || '').trim()
+  const lifecycleCwd = (() => {
+    if (!payloadCwd) return undefined
+    try {
+      return fs.statSync(payloadCwd).isDirectory() ? path.resolve(payloadCwd) : undefined
+    } catch {
+      return undefined
+    }
+  })()
   const child = spawn(process.execPath, [lifecycle], {
     input: JSON.stringify(normalized.payload),
     encoding: 'utf8',
     maxBuffer: 8 * 1024 * 1024,
+    ...(lifecycleCwd ? { cwd: lifecycleCwd } : {}),
     env: { ...(options.env || process.env), DEVCODEX_HOST_PLATFORM: host }
   })
   if (child.error) {
@@ -547,6 +691,11 @@ function applyCliEnvironmentOverrides (argv, env = process.env) {
   if (workspaceRootIndex >= 0 && argv[workspaceRootIndex + 1]) {
     env.DEVCODEX_WORKSPACE_ROOT = path.resolve(argv[workspaceRootIndex + 1])
   }
+  const contextEpochIndex = argv.indexOf('--context-epoch')
+  if (contextEpochIndex >= 0 && argv[contextEpochIndex + 1]) {
+    env.DEVCODEX_CONTEXT_EPOCH = String(argv[contextEpochIndex + 1]).trim()
+    env.DEVCODEX_CONTEXT_EPOCH_SOURCE = 'host-adapter-cli'
+  }
   const eventIndex = argv.indexOf('--event')
   if (eventIndex >= 0 && argv[eventIndex + 1]) {
     env.DEVCODEX_HOST_EVENT = String(argv[eventIndex + 1]).trim()

hooks/_runtime/lifecycle-project-target.cjs

@@ -170,12 +170,12 @@ function buildLifecycleProjectTargetUtils({
   }
 
   function resolvePromptTarget(previousState, payload, prompt, projectCandidate) {
-    if (hasMultiProjectExemption(prompt)) {
-      return { activeProject: '', activeScope: LAYOUT.enabled ? 'workspace' : 'project', source: 'workspace-exemption', clearSticky: true }
-    }
     if (projectCandidate.project) {
       return { activeProject: projectCandidate.project, activeScope: 'project', source: projectCandidate.source || 'explicit' }
     }
+    if (hasMultiProjectExemption(prompt)) {
+      return { activeProject: '', activeScope: LAYOUT.enabled ? 'workspace' : 'project', source: 'workspace-exemption', clearSticky: true }
+    }
     if (CONTEXT_PROJECT) {
       return { activeProject: CONTEXT_PROJECT, activeScope: 'project', source: 'context' }
     }

hooks/_runtime/lifecycle.cjs

@@ -1247,6 +1247,32 @@ async function main() {
       writeStdout(noopOutput())
       return
     }
+    if (payload.devcodex_host_transform_only === true &&
+        state.contextAcquisition?.contextEpoch) {
+      let progressiveSkillRouteMsg = ''
+      try {
+        const {
+          formatSkillRouteBootstrapInjection
+        } = require('./skill-route-tool.cjs')
+        if (state.progressiveSkillRoute?.bootstrap) {
+          progressiveSkillRouteMsg = formatSkillRouteBootstrapInjection(
+            state.progressiveSkillRoute.bootstrap
+          )
+        }
+      } catch {}
+      state.lastReason = 'copilot-transform-projection'
+      saveState(state)
+      writeStdout(contextMessageOutput(
+        'UserPromptSubmit',
+        [
+          buildBootstrapMessage(state),
+          buildExecutionModeContextMessage(state),
+          buildGovernanceIntakeContextMessage(state.governanceIntake),
+          progressiveSkillRouteMsg
+        ].filter(Boolean).join('\n\n')
+      ))
+      return
+    }
     const workflowCompletionLifecycle = state.workflowCompletionLifecycle
     state = resetState(mode, state)
     state.workflowCompletionLifecycle = workflowCompletionLifecycle

hooks/_runtime/skill-route-tool.cjs

@@ -1197,6 +1197,22 @@ function handleSkillRoute (input, options = {}) {
   }
 }
 
+function formatSkillRouteBootstrapInjection (bootstrap) {
+  const injectionText = [
+    '### DevCodex · SkillRouteBootstrapV1',
+    JSON.stringify(bootstrap),
+    '',
+    'Use the local `skill_route` Tool. For a non-explicit task, read every catalog page before one `commit` choice (`skillId` is one id or null).',
+    'Do not infer workflow roots, paths, dependencies, or body content. After a complete plan, call `load_stage` only when entering that stage.'
+  ].join('\n')
+  if (byteLength(injectionText) > 4 * 1024) {
+    const error = new Error('SKILL_ROUTE_BOOTSTRAP_BUDGET_BLOCKED')
+    error.code = 'SKILL_ROUTE_BOOTSTRAP_BUDGET_BLOCKED'
+    throw error
+  }
+  return injectionText
+}
+
 function bootstrapSkillRouteForTurn (input, options = {}) {
   const target = resolveProjectTarget(options.inputRoot || input.cwd || process.cwd(), input.project)
   const modeReceipt = resolveSkillRouteMode({
@@ -1229,18 +1245,7 @@ function bootstrapSkillRouteForTurn (input, options = {}) {
     runtimeRoot: options.runtimeRoot,
     packageRoot: options.packageRoot
   })
-  const injectionText = [
-    '### DevCodex · SkillRouteBootstrapV1',
-    JSON.stringify(outcome.bootstrap),
-    '',
-    'Use the local `skill_route` Tool. For a non-explicit task, read every catalog page before one `commit` choice (`skillId` is one id or null).',
-    'Do not infer workflow roots, paths, dependencies, or body content. After a complete plan, call `load_stage` only when entering that stage.'
-  ].join('\n')
-  if (byteLength(injectionText) > 4 * 1024) {
-    const error = new Error('SKILL_ROUTE_BOOTSTRAP_BUDGET_BLOCKED')
-    error.code = 'SKILL_ROUTE_BOOTSTRAP_BUDGET_BLOCKED'
-    throw error
-  }
+  const injectionText = formatSkillRouteBootstrapInjection(outcome.bootstrap)
   return {
     schemaVersion: 'SkillRouteBootstrapOutcomeV1',
     active: true,
@@ -1260,6 +1265,7 @@ module.exports = {
   finalizeResponse,
   handleSkillRoute,
   evaluateProgressiveSkillRouteStop,
+  formatSkillRouteBootstrapInjection,
   bootstrapSkillRouteForTurn,
   summarizePlan,
   buildObligationLedger,

package.json

@@ -90,6 +90,7 @@
     "test:skill-route": "npm run test:skill-intents && npm run test:skill-route-contracts && npm run test:skill-route-state && npm run test:skill-route-retirement && npm run test:skill-route-lifecycle",
     "probe:skill-route:s15:grok": "node scripts/probe-skill-route-s15-grok.js",
     "probe:skill-route:s15:host": "node scripts/probe-skill-route-s15-host.js",
+    "sample:skill-route:retirement": "node scripts/run-skill-route-retirement-sample.js",
     "test:global-host-config": "node scripts/test-global-host-config.js && node scripts/test-global-host-runtime-verifier.js && npm run test:skill-native-coexistence && npm run test:global-skill-runtime",
     "test:global-install-smoke": "node scripts/test-global-install-smoke.js",
     "benchmark:execution-chain": "node scripts/benchmark-execution-chain.js",
@@ -211,6 +212,7 @@
     "scripts/check-skill-route-retirement.js",
     "scripts/probe-skill-route-s15-grok.js",
     "scripts/probe-skill-route-s15-host.js",
+    "scripts/run-skill-route-retirement-sample.js",
     "scripts/lib/skill-route-test-fixture.js",
     "scripts/test-implement-start-gate.js",
     "scripts/lib/skills-deploy-mode.js",