sneakoscope 6.0.3 → 6.1.2

package/dist/core/wiki-coordinate.js

@@ -1,8 +1,11 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { sha256 } from './fsx.js';
 export const WIKI_COORD_SCHEMA = 'sks.wiki-coordinate.v1';
 export const WIKI_VOXEL_SCHEMA = 'sks.wiki-voxel.v1';
 export const WIKI_TAU = Math.PI * 2;
 export const WIKI_VOXEL_LAYERS = Object.freeze(['sem', 'trust', 'fresh', 'prio', 'conflict', 'route', 'cost']);
+export const DEFAULT_WIKI_VOXEL_QUANTIZATION = Object.freeze({ domain: 64, radius: 16, phase: 64 });
 export function clamp01(x) {
     return Math.max(0, Math.min(1, Number.isFinite(x) ? x : 0));
 }
@@ -247,10 +250,20 @@ function riskScore(value) {
     };
     return table[String(value || 'medium')] ?? 0.35;
 }
-function quantizeVoxelCoord(c = []) {
-    const domain = Math.max(0, Math.min(63, Math.floor((wrapTau(c[0]) / WIKI_TAU) * 64)));
-    const radius = Math.max(0, Math.min(15, Math.floor(clamp01(Number(c[1])) * 16)));
-    const phase = Math.max(0, Math.min(63, Math.floor((wrapTau(c[2]) / WIKI_TAU) * 64)));
+function normalizeVoxelQuantization(value = {}) {
+    const normalize = (key) => {
+        const candidate = Number(value?.[key]);
+        return Number.isInteger(candidate) && candidate > 0 && candidate <= 65_536
+            ? candidate
+            : DEFAULT_WIKI_VOXEL_QUANTIZATION[key];
+    };
+    return { domain: normalize('domain'), radius: normalize('radius'), phase: normalize('phase') };
+}
+function quantizeVoxelCoord(c = [], value = DEFAULT_WIKI_VOXEL_QUANTIZATION) {
+    const quantization = normalizeVoxelQuantization(value);
+    const domain = Math.max(0, Math.min(quantization.domain - 1, Math.floor((wrapTau(c[0]) / WIKI_TAU) * quantization.domain)));
+    const radius = Math.max(0, Math.min(quantization.radius - 1, Math.floor(clamp01(Number(c[1])) * quantization.radius)));
+    const phase = Math.max(0, Math.min(quantization.phase - 1, Math.floor((wrapTau(c[2]) / WIKI_TAU) * quantization.phase)));
     return `${domain}:${radius}:${phase}`;
 }
 function conflictShadow(anchor = {}, claim = {}) {
@@ -272,8 +285,10 @@ function layerVector(anchor = {}, claim = {}, q3 = []) {
     const trust = Number.isFinite(Number(anchor.trust_score))
         ? Number(anchor.trust_score)
         : clamp01((0.7 * statusScore(claim.status || anchor.st)) + (0.3 * Math.log1p(Number(claim.evidence_count) || 0) / Math.log1p(8)));
+    const concentration = Number(anchor.c?.[3]);
+    const similarity = Number(anchor.sim);
     return [
-        clamp01((Number(anchor.c?.[3]) || 0.85) * (Number(anchor.sim) || 1)),
+        clamp01((Number.isFinite(concentration) ? concentration : 0.85) * (Number.isFinite(similarity) ? similarity : 1)),
         clamp01(trust),
         freshnessScore(claim.freshness),
         clamp01((required / 1.25) + (requestCount * 0.04) + (strongFeedback * 0.18)),
@@ -282,15 +297,16 @@ function layerVector(anchor = {}, claim = {}, q3 = []) {
         clamp01(tokenCost / 360)
     ].map(round4);
 }
-export function buildWikiVoxelOverlay({ anchors = [], claimsById = new Map(), q3 = [], quantization = { domain: 64, radius: 16, phase: 64 } } = {}) {
+export function buildWikiVoxelOverlay({ anchors = [], claimsById = new Map(), q3 = [], quantization = DEFAULT_WIKI_VOXEL_QUANTIZATION } = {}) {
+    const normalizedQuantization = normalizeVoxelQuantization(quantization);
     const rows = (anchors || []).map((anchor) => {
         const claim = claimsById instanceof Map ? claimsById.get(anchor.id) || {} : {};
-        return [quantizeVoxelCoord(anchor.c), anchor.id, layerVector(anchor, claim, q3)];
+        return [quantizeVoxelCoord(anchor.c, normalizedQuantization), anchor.id, layerVector(anchor, claim, q3)];
     });
     return {
         s: WIKI_VOXEL_SCHEMA,
         base: WIKI_COORD_SCHEMA,
-        q: quantization,
+        q: normalizedQuantization,
         l: WIKI_VOXEL_LAYERS,
         v: rows
     };
@@ -305,16 +321,48 @@ export function validateWikiVoxelOverlay(overlay = {}, anchorIds = null) {
         issues.push({ id: 'vx_base', severity: 'error' });
     if (!Array.isArray(overlay.l) || overlay.l.join('|') !== WIKI_VOXEL_LAYERS.join('|'))
         issues.push({ id: 'vx_layers', severity: 'error' });
+    const rawQuantization = overlay.q;
+    for (const key of ['domain', 'radius', 'phase']) {
+        const value = Number(rawQuantization?.[key]);
+        if (!Number.isInteger(value) || value <= 0 || value > 65_536)
+            issues.push({ id: 'vx_quantization', severity: 'error', axis: key });
+    }
+    const quantization = normalizeVoxelQuantization(rawQuantization);
+    const expectedById = new Map();
+    if (anchorIds instanceof Map) {
+        for (const [id, value] of anchorIds) {
+            const coord = Array.isArray(value) ? value : value?.c;
+            expectedById.set(String(id), Array.isArray(coord) && coord.length === 4 ? quantizeVoxelCoord(coord, quantization) : null);
+        }
+    }
+    else if (anchorIds instanceof Set) {
+        for (const id of anchorIds)
+            expectedById.set(String(id), null);
+    }
     const rows = Array.isArray(overlay.v) ? overlay.v : [];
+    const seenIds = new Set();
     for (const row of rows) {
         const id = row[1];
         const values = row[2];
-        if (!/^\d{1,2}:\d{1,2}:\d{1,2}$/.test(String(row[0] || '')))
+        const key = String(row[0] || '');
+        const parts = /^\d+:\d+:\d+$/.test(key) ? key.split(':').map(Number) : [];
+        const [domainKey = -1, radiusKey = -1, phaseKey = -1] = parts;
+        if (parts.length !== 3
+            || domainKey < 0 || domainKey >= quantization.domain
+            || radiusKey < 0 || radiusKey >= quantization.radius
+            || phaseKey < 0 || phaseKey >= quantization.phase)
             issues.push({ id: 'vx_key', severity: 'error', anchor: id });
         if (!id)
             issues.push({ id: 'vx_id', severity: 'error' });
-        if (anchorIds && !anchorIds.has(id))
+        if (id && seenIds.has(String(id)))
+            issues.push({ id: 'vx_duplicate_anchor', severity: 'error', anchor: id });
+        if (id)
+            seenIds.add(String(id));
+        if (anchorIds && !expectedById.has(String(id)))
             issues.push({ id: 'vx_anchor', severity: 'error', anchor: id });
+        const expectedKey = expectedById.get(String(id));
+        if (expectedKey && key !== expectedKey)
+            issues.push({ id: 'vx_coord_mismatch', severity: 'error', anchor: id });
         if (!Array.isArray(values) || values.length !== WIKI_VOXEL_LAYERS.length)
             issues.push({ id: 'vx_tuple', severity: 'error', anchor: id });
         else {
@@ -325,6 +373,10 @@ export function validateWikiVoxelOverlay(overlay = {}, anchorIds = null) {
             }
         }
     }
+    for (const id of expectedById.keys()) {
+        if (!seenIds.has(id))
+            issues.push({ id: 'vx_missing_anchor', severity: 'error', anchor: id });
+    }
     return { ok: issues.length === 0, checked: rows.length, issues };
 }
 function expandedAnchors(index = {}) {
@@ -365,7 +417,55 @@ function validateTrustFields(anchor = {}, issues = []) {
         issues.push({ id: 'invalid_trust_action', severity: 'error', anchor: anchor.id });
     }
 }
-export function validateWikiCoordinateIndex(index = {}) {
+function pathIsInsideRoot(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+function hydrationValidationRoot(root) {
+    if (!root)
+        return null;
+    const resolved = path.resolve(String(root));
+    try {
+        return { resolved, real: fs.realpathSync(resolved), cache: new Map() };
+    }
+    catch {
+        return { resolved, real: null, cache: new Map() };
+    }
+}
+function validateHydrationPath(anchor = {}, root, issues = []) {
+    if (!root || !hasOwn(anchor, 'p') || anchor.p == null)
+        return;
+    if (typeof anchor.p !== 'string' || !anchor.p.trim()) {
+        issues.push({ id: 'invalid_hydration_path', severity: 'error', anchor: anchor.id, path: anchor.p });
+        return;
+    }
+    const citation = anchor.p.trim();
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(citation))
+        return;
+    const resolvedCitation = path.isAbsolute(citation) ? path.resolve(citation) : path.resolve(root.resolved, citation);
+    if (!pathIsInsideRoot(root.resolved, resolvedCitation)) {
+        issues.push({ id: 'hydration_path_outside_root', severity: 'error', anchor: anchor.id, path: citation });
+        return;
+    }
+    let realCitation = root.cache.get(resolvedCitation) || null;
+    if (!root.cache.has(resolvedCitation)) {
+        try {
+            realCitation = fs.realpathSync(resolvedCitation);
+        }
+        catch {
+            realCitation = null;
+        }
+        root.cache.set(resolvedCitation, realCitation);
+    }
+    if (!realCitation) {
+        issues.push({ id: 'hydration_path_missing', severity: 'error', anchor: anchor.id, path: citation });
+        return;
+    }
+    if (!root.real || !pathIsInsideRoot(root.real, realCitation)) {
+        issues.push({ id: 'hydration_path_outside_root', severity: 'error', anchor: anchor.id, path: citation });
+    }
+}
+export function validateWikiCoordinateIndex(index = {}, options = {}) {
     const issues = [];
     if (index.schema !== WIKI_COORD_SCHEMA)
         issues.push({ id: 'schema_mismatch', severity: 'error' });
@@ -375,6 +475,10 @@ export function validateWikiCoordinateIndex(index = {}) {
     if (!anchors.length && !Array.isArray(index.anchors) && !Array.isArray(index.a))
         issues.push({ id: 'anchors_missing', severity: 'error' });
     const seen = new Set();
+    const hydrationRoot = hydrationValidationRoot(options.root);
+    const compactClaims = new Map((Array.isArray(options.claims) ? options.claims : [])
+        .filter((claim) => claim && typeof claim.id === 'string')
+        .map((claim) => [String(claim.id), claim]));
     for (const anchor of anchors) {
         if (!anchor.id)
             issues.push({ id: 'anchor_id_missing', severity: 'error' });
@@ -385,13 +489,25 @@ export function validateWikiCoordinateIndex(index = {}) {
             issues.push({ id: 'invalid_rgba_key', severity: 'error', anchor: anchor.id });
         if (!Array.isArray(anchor.c) || anchor.c.length !== 4)
             issues.push({ id: 'invalid_coord_tuple', severity: 'error', anchor: anchor.id });
+        if (!/^[0-9a-f]{16}$/i.test(String(anchor.h || '')))
+            issues.push({ id: 'invalid_anchor_hash', severity: 'error', anchor: anchor.id });
+        const compactClaim = compactClaims.get(String(anchor.id));
+        if (compactClaim && typeof compactClaim.text === 'string') {
+            const expectedHash = sha256(`${anchor.id}\n${compactClaim.text}`).slice(0, 16);
+            if (anchor.h !== expectedHash)
+                issues.push({ id: 'anchor_hash_mismatch', severity: 'error', anchor: anchor.id });
+            if (compactClaim.h !== expectedHash)
+                issues.push({ id: 'compact_claim_hash_mismatch', severity: 'error', anchor: anchor.id });
+        }
         validateTrustFields(anchor, issues);
+        validateHydrationPath(anchor, hydrationRoot, issues);
     }
     const voxel = index.vx || index.voxel_overlay;
     if (!voxel)
         issues.push({ id: 'vx_missing', severity: 'error' });
     else {
-        const voxelValidation = validateWikiVoxelOverlay(voxel, seen);
+        const anchorMap = new Map(anchors.map((anchor) => [String(anchor.id), anchor]));
+        const voxelValidation = validateWikiVoxelOverlay(voxel, anchorMap);
         for (const issue of voxelValidation.issues)
             issues.push(issue);
     }

package/dist/core/work-order-ledger.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { nowIso, readJson, writeJsonAtomic } from './fsx.js';
+import { exists, nowIso, readJson, writeJsonAtomic } from './fsx.js';
 import { ARTIFACT_FILES, validateWorkOrderLedger } from './artifact-schemas.js';
 import { promptRequirementItems } from './questions.js';
 export function createWorkOrderLedger({ missionId = 'unassigned', route = 'team', requests = [], sourcesComplete = false } = {}) {
@@ -28,7 +28,7 @@ export function createWorkOrderLedger({ missionId = 'unassigned', route = 'team'
         source_inventory_complete: Boolean(sourcesComplete),
         all_customer_requests_preserved: items.every((item) => Boolean(item.source.verbatim)),
         all_customer_requests_mapped: items.every((item) => item.implementation_tasks.length > 0 || item.blocker.blocked === true),
-        all_work_items_verified: items.length > 0 && items.every((item) => item.status === 'verified' || item.status === 'blocked'),
+        all_work_items_verified: items.length > 0 && items.every(workOrderItemResolved),
         items
     };
 }
@@ -51,11 +51,20 @@ export function evaluateWorkOrderCoverage(ledger) {
         blockers.push('work_order_items_not_verified');
     let uncovered_count = 0;
     for (const item of (ledger.items || [])) {
-        const isVerified = item.status === 'verified';
+        const isVerified = item.status === 'verified'
+            && Array.isArray(item.implementation_evidence) && item.implementation_evidence.length > 0
+            && Array.isArray(item.verification_evidence) && item.verification_evidence.length > 0;
         const isBlockedWithEvidence = item.status === 'blocked' && item.blocker?.blocked === true;
         if (!isVerified && !isBlockedWithEvidence) {
             uncovered_count += 1;
-            blockers.push(`work_order_uncovered:${item.id}:"${item.source?.verbatim?.slice(0, 40) || ''}"`);
+            if (item.status === 'verified' && (!Array.isArray(item.implementation_evidence) || item.implementation_evidence.length === 0)) {
+                blockers.push(`work_order_implementation_evidence_missing:${item.id}`);
+            }
+            if (item.status === 'verified' && (!Array.isArray(item.verification_evidence) || item.verification_evidence.length === 0)) {
+                blockers.push(`work_order_verification_evidence_missing:${item.id}`);
+            }
+            if (item.status !== 'verified')
+                blockers.push(`work_order_uncovered:${item.id}:"${item.source?.verbatim?.slice(0, 40) || ''}"`);
         }
     }
     return { ok: blockers.length === 0, blockers, uncovered_count };
@@ -69,7 +78,7 @@ export function updateWorkOrderItem(ledger, id, patch = {}) {
             : ((item.implementation_tasks || []).length > 0 || item.blocker?.blocked === true)),
         all_work_items_verified: (ledger.items || []).every((item) => {
             const next = item.id === id ? { ...item, ...patch } : item;
-            return next.status === 'verified' || next.status === 'blocked';
+            return workOrderItemResolved(next);
         })
     };
 }
@@ -79,16 +88,168 @@ export function updateWorkOrderItem(ledger, id, patch = {}) {
  * so every item is registered verbatim before any execution starts.
  */
 export async function createAndWriteWorkOrderLedgerForPrompt(dir, { missionId, route, prompt } = {}) {
-    const { items, truncated } = promptRequirementItems(String(prompt || ''));
+    const parsed = semanticSliceRequirementItems(String(prompt || '')) || promptRequirementItems(String(prompt || ''));
+    const { items, truncated } = parsed;
     const requests = items.map((item) => ({
         type: 'chat_text',
         verbatim: item.text,
+        normalized_requirement: item.context ? `${item.context}: ${item.text}` : item.text,
+        acceptance_criteria: item.acceptance_context ? [item.acceptance_context] : [],
         location: `prompt:${item.id}`
     }));
-    const ledger = createWorkOrderLedger({ missionId, route, requests, sourcesComplete: !truncated });
+    const candidate = createWorkOrderLedger({ missionId, route, requests, sourcesComplete: !truncated });
+    const existing = await readWorkOrderLedger(dir);
+    const ledger = mergeWorkOrderLedger(existing, candidate);
     await writeWorkOrderLedger(dir, ledger);
     return ledger;
 }
+export function mergeWorkOrderLedger(existing, candidate) {
+    if (!existing || !Array.isArray(existing.items))
+        return candidate;
+    const seen = new Set(existing.items.map(workOrderRequirementKey).filter(Boolean));
+    const appended = (candidate?.items || [])
+        .filter((item) => {
+        const key = workOrderRequirementKey(item);
+        if (!key || seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    })
+        .map((item, index) => ({
+        ...item,
+        id: `WO-${String(existing.items.length + index + 1).padStart(3, '0')}`
+    }));
+    if (appended.length === 0)
+        return existing;
+    const items = [...existing.items, ...appended];
+    return {
+        ...existing,
+        mission_id: existing.mission_id || candidate.mission_id,
+        route: existing.route || candidate.route,
+        source_inventory_complete: Boolean(existing.source_inventory_complete && candidate.source_inventory_complete),
+        all_customer_requests_preserved: items.every((item) => Boolean(item.source?.verbatim)),
+        all_customer_requests_mapped: items.every((item) => (item.implementation_tasks || []).length > 0 || item.blocker?.blocked === true),
+        all_work_items_verified: items.length > 0 && items.every(workOrderItemResolved),
+        items
+    };
+}
+function workOrderRequirementKey(item) {
+    return String(item?.source?.verbatim || item?.normalized_requirement || '')
+        .normalize('NFKC')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+const SEMANTIC_SLICE_ITEM_CEILING = 128;
+function semanticSliceRequirementItems(prompt) {
+    const text = String(prompt || '').replace(/(?:^|\s)\$[A-Za-z0-9_-]+(?:\s|$)/g, ' ').trim();
+    const repeatedScopes = repeatedNamedSliceParts(text);
+    if (repeatedScopes)
+        return repeatedScopes;
+    const marker = /\bslices?\s*:\s*|(?:슬라이스|영역|항목)\s*:\s*/i.exec(text);
+    if (!marker)
+        return null;
+    const context = text.slice(0, marker.index).replace(/\s+/g, ' ').trim();
+    const body = text.slice(marker.index + marker[0].length).trim();
+    if (!body)
+        return null;
+    const semicolonParts = body.split(/[;；]/).map((part) => part.trim()).filter(Boolean);
+    let parts = semicolonParts.length > 1 ? semicolonParts : numberedSliceParts(body);
+    let instructionTail = '';
+    if (parts.length <= 1) {
+        const sentenceSplit = sentenceSliceParts(body);
+        parts = sentenceSplit.parts;
+        instructionTail = sentenceSplit.tail;
+    }
+    if (parts.length <= 1)
+        return null;
+    const last = splitSliceInstructionTail(parts.at(-1) || '');
+    parts[parts.length - 1] = last.topic;
+    instructionTail ||= last.tail;
+    const topics = parts.map(stripSliceMarker).filter(Boolean);
+    if (topics.length <= 1)
+        return null;
+    const truncated = topics.length > SEMANTIC_SLICE_ITEM_CEILING;
+    const kept = topics.slice(0, SEMANTIC_SLICE_ITEM_CEILING);
+    return {
+        items: kept.map((topic, index) => ({
+            id: `REQ-${String(index + 1).padStart(3, '0')}`,
+            text: topic,
+            context,
+            acceptance_context: instructionTail,
+            required: true,
+            confidence: 1
+        })),
+        truncated,
+        truncated_count: truncated ? topics.length - SEMANTIC_SLICE_ITEM_CEILING : 0
+    };
+}
+function repeatedNamedSliceParts(text) {
+    const matches = [...text.matchAll(/(?:^|\s)(?:scope|slice|영역|범위)\s*(\d{1,3})\s*[:：]\s*/gi)];
+    if (matches.length < 2)
+        return null;
+    const context = text.slice(0, Number(matches[0]?.index || 0)).replace(/\s+/g, ' ').trim();
+    const rawParts = matches.map((match, index) => {
+        const start = Number(match.index || 0) + match[0].length;
+        const end = index + 1 < matches.length ? Number(matches[index + 1]?.index ?? text.length) : text.length;
+        return text.slice(start, end).trim();
+    });
+    const last = splitSliceInstructionTail(rawParts.at(-1) || '');
+    rawParts[rawParts.length - 1] = last.topic;
+    const topics = rawParts.map(stripSliceMarker).filter(Boolean);
+    const truncated = topics.length > SEMANTIC_SLICE_ITEM_CEILING;
+    return {
+        items: topics.slice(0, SEMANTIC_SLICE_ITEM_CEILING).map((topic, index) => ({
+            id: `REQ-${String(index + 1).padStart(3, '0')}`,
+            text: topic,
+            context,
+            acceptance_context: last.tail,
+            required: true,
+            confidence: 1
+        })),
+        truncated,
+        truncated_count: truncated ? topics.length - SEMANTIC_SLICE_ITEM_CEILING : 0
+    };
+}
+function numberedSliceParts(text) {
+    const matches = [...text.matchAll(/(?:^|\s)(?:\d{1,3}[.)]|[①-⑳])\s+/g)];
+    if (matches.length < 2)
+        return [text];
+    return matches.map((match, index) => {
+        const start = Number(match.index || 0) + match[0].length;
+        const end = index + 1 < matches.length ? Number(matches[index + 1]?.index ?? text.length) : text.length;
+        return text.slice(start, end).trim();
+    }).filter(Boolean);
+}
+function sentenceSliceParts(text) {
+    const sentences = text.split(/(?<=[.!?。！？])\s+/).map((part) => part.trim()).filter(Boolean);
+    if (sentences.length < 2)
+        return { parts: [text], tail: '' };
+    const instructionIndex = sentences.findIndex((sentence) => isSliceInstruction(sentence));
+    return instructionIndex > 1
+        ? { parts: sentences.slice(0, instructionIndex), tail: sentences.slice(instructionIndex).join(' ') }
+        : { parts: [text], tail: '' };
+}
+function splitSliceInstructionTail(text) {
+    const sentences = text.split(/(?<=[.!?。！？])\s+/).map((part) => part.trim()).filter(Boolean);
+    const instructionIndex = sentences.findIndex((sentence, index) => index > 0 && isSliceInstruction(sentence));
+    if (instructionIndex < 0)
+        return { topic: text.trim(), tail: '' };
+    return {
+        topic: sentences.slice(0, instructionIndex).join(' ').trim(),
+        tail: sentences.slice(instructionIndex).join(' ').trim()
+    };
+}
+function isSliceInstruction(text) {
+    return /^(?:inspect|review|check|verify|use|do\s+not|never|return|report|limit|only|검사|검토|확인|검증|사용|수정하지|실행하지|반환|보고|제한)/i.test(String(text || '').trim());
+}
+function stripSliceMarker(text) {
+    return String(text || '')
+        .replace(/^\s*(?:\d{1,3}[.)]|[①-⑳]|[-*])\s*/, '')
+        .replace(/[.!?。！？]+$/, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
 /**
  * Closes out every item in a mission's ledger to a terminal state once the
  * route's own gate has decided ok/not-ok, so evaluateStop's coverage gate
@@ -101,14 +262,51 @@ export async function closeWorkOrderLedgerForRouteResult(dir, { ok, blockers = [
     const ledger = await readWorkOrderLedger(dir);
     if (!ledger || !Array.isArray(ledger.items) || ledger.items.length === 0)
         return null;
+    const routeEvidence = ok ? await existingRouteEvidence(dir) : [];
+    const verified = ok && routeEvidence.length > 0;
     let next = ledger;
     for (const item of ledger.items) {
-        const patch = ok
-            ? { status: 'verified', implementation_tasks: item.implementation_tasks?.length ? item.implementation_tasks : ['route_completion'] }
-            : { status: 'blocked', blocker: { blocked: true, reason: blockers.join(', ') || 'route_completion_blocked', needed_to_unblock: 'resolve the route blockers and re-run' } };
+        const patch = verified
+            ? {
+                status: 'verified',
+                implementation_tasks: item.implementation_tasks?.length ? item.implementation_tasks : ['route_completion'],
+                implementation_evidence: item.implementation_evidence?.length ? item.implementation_evidence : routeEvidence,
+                verification_evidence: item.verification_evidence?.length ? item.verification_evidence : routeEvidence
+            }
+            : {
+                status: 'blocked',
+                blocker: {
+                    blocked: true,
+                    reason: blockers.join(', ') || (ok ? 'route_completion_evidence_missing' : 'route_completion_blocked'),
+                    needed_to_unblock: ok ? 'write the route gate/proof artifact and close the work order again' : 'resolve the route blockers and re-run'
+                }
+            };
         next = updateWorkOrderItem(next, item.id, patch);
     }
     await writeWorkOrderLedger(dir, next);
     return next;
 }
+function workOrderItemResolved(item) {
+    if (item?.status === 'blocked')
+        return item?.blocker?.blocked === true;
+    return item?.status === 'verified'
+        && Array.isArray(item?.implementation_evidence) && item.implementation_evidence.length > 0
+        && Array.isArray(item?.verification_evidence) && item.verification_evidence.length > 0;
+}
+async function existingRouteEvidence(dir) {
+    const candidates = [
+        'completion-proof.json',
+        'naruto-gate.json',
+        'loop-graph-proof.json',
+        'run-gate.json',
+        'agents/agent-proof-evidence.json',
+        'agents/agent-output-validation.json'
+    ];
+    const found = [];
+    for (const candidate of candidates) {
+        if (await exists(path.join(dir, candidate)))
+            found.push(candidate);
+    }
+    return found;
+}
 //# sourceMappingURL=work-order-ledger.js.map

package/dist/core/zellij/zellij-command.js

@@ -32,7 +32,7 @@ export async function runZellij(args = [], opts = {}) {
     const stderr = String(result.stderr || '');
     const missing = result.code === -1 && /ENOENT|not found|spawn zellij/i.test(stderr);
     const socketPathTooLong = isZellijSocketPathTooLong(stderr);
-    return {
+    const record = {
         ok,
         command: 'zellij',
         args: [...args],
@@ -43,6 +43,7 @@ export async function runZellij(args = [], opts = {}) {
         stdout_bytes: result.stdoutBytes,
         stderr_bytes: result.stderrBytes,
         timed_out: result.timedOut,
+        output_truncated: result.truncated,
         duration_ms: Date.now() - started,
         env: preparedEnv.meta,
         blockers: ok ? [] : [missing ? 'zellij_missing' : socketPathTooLong ? 'zellij_socket_path_too_long' : result.timedOut ? 'zellij_command_timeout' : 'zellij_command_failed'],
@@ -51,6 +52,16 @@ export async function runZellij(args = [], opts = {}) {
             ...(ok || opts.optional !== true ? [] : ['zellij_command_failed_optional'])
         ]
     };
+    Object.defineProperty(record, 'stdout_for_parsing', {
+        value: String(result.stdout || ''),
+        enumerable: false,
+        configurable: false,
+        writable: false
+    });
+    return record;
+}
+export function zellijCommandStdout(result) {
+    return String(result?.stdout_for_parsing ?? result?.stdout_tail ?? '');
 }
 export async function prepareZellijProcessEnv(envOverrides = {}) {
     const mergedEnv = { ...process.env, ...envOverrides };

package/dist/core/zellij/zellij-dashboard-pane.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { ensureDir, nowIso, writeJsonAtomic } from '../fsx.js';
-import { runZellij } from './zellij-command.js';
+import { runZellij, zellijCommandStdout } from './zellij-command.js';
 import { extractZellijPaneIdFromOutput } from './zellij-lane-runtime.js';
 import { buildZellijDashboardSnapshot } from './zellij-dashboard-renderer.js';
 export const ZELLIJ_DASHBOARD_PANE_SCHEMA = 'sks.zellij-dashboard-pane.v1';
@@ -22,8 +22,8 @@ export async function openZellijDashboardPane(input) {
         optional: false
     });
     const stdoutPaneId = launch.ok ? extractZellijPaneIdFromOutput(launch.stdout_tail) : null;
-    const listed = await runZellij(['--session', input.sessionName, 'action', 'list-panes', '--json', '--all'], { cwd, timeoutMs: 5000, optional: true });
-    const rows = parseRows(listed.stdout_tail);
+    const listed = await runZellij(['--session', input.sessionName, 'action', 'list-panes', '--json', '--all'], { cwd, timeoutMs: 5000, maxOutputBytes: 1024 * 1024, optional: true });
+    const rows = parseRows(zellijCommandStdout(listed));
     const pane = stdoutPaneId ? null : rows.find((row) => String(row.title || row.name || '').includes(paneTitle));
     const paneId = stdoutPaneId || pane?.pane_id || pane?.paneId || pane?.id || null;
     const dump = await runZellij(['--session', input.sessionName, 'action', 'dump-screen'], { cwd, timeoutMs: 5000, optional: true });

package/dist/core/zellij/zellij-fake-adapter.js

@@ -89,7 +89,9 @@ export async function runFakeZellij(args = [], opts = {}) {
         session_name: sessionName,
         version,
         exit_code: result.code,
-        duration_ms: Date.now() - startedAt
+        duration_ms: Date.now() - startedAt,
+        sks_zellij_viewports: env.SKS_ZELLIJ_VIEWPORTS || null,
+        sks_zellij_refresh_ms: env.SKS_ZELLIJ_REFRESH_MS || null
     });
     return result;
 }