sneakoscope 2.0.2 → 2.0.5

package/dist/core/naruto/naruto-role-policy.js

@@ -0,0 +1,107 @@
+export const NARUTO_WRITE_ROLES = new Set([
+    'implementer',
+    'modifier',
+    'test_writer',
+    'conflict_resolver',
+    'rollback_planner',
+    'integrator'
+]);
+export const NARUTO_IMPLEMENTATION_LIKE_ROLES = new Set([
+    'implementer',
+    'modifier',
+    'test_writer',
+    'conflict_resolver'
+]);
+export function narutoRoleAllowsWrite(role) {
+    return NARUTO_WRITE_ROLES.has(role);
+}
+export function mapWorkKindToNarutoRole(kind) {
+    switch (kind) {
+        case 'implementation':
+            return 'implementer';
+        case 'code_modification':
+        case 'refactor':
+        case 'patch_rebase':
+            return 'modifier';
+        case 'test_generation':
+            return 'test_writer';
+        case 'test_execution':
+        case 'verification':
+        case 'ux_review':
+        case 'ppt_review':
+        case 'image_review':
+            return 'verifier';
+        case 'research':
+            return 'researcher';
+        case 'documentation':
+            return 'modifier';
+        case 'conflict_resolution':
+            return 'conflict_resolver';
+        case 'rollback_preparation':
+            return 'rollback_planner';
+        case 'integration_support':
+            return 'integrator';
+        case 'final_review_input_pack':
+            return 'gpt_final_arbiter';
+    }
+}
+export function mapNarutoRoleToAgentRole(role) {
+    switch (role) {
+        case 'implementer':
+        case 'modifier':
+        case 'test_writer':
+            return 'implementer';
+        case 'researcher':
+            return 'research';
+        case 'conflict_resolver':
+        case 'rollback_planner':
+        case 'integrator':
+        case 'gpt_final_arbiter':
+            return 'integrator';
+        case 'verifier':
+            return 'verifier';
+    }
+}
+export function buildNarutoRoleDistribution(workItems, opts = {}) {
+    const readonly = opts.readonly === true;
+    const counts = new Map();
+    const workItemRoles = workItems.map((item) => {
+        const role = mapWorkKindToNarutoRole(item.kind);
+        counts.set(role, (counts.get(role) || 0) + 1);
+        return {
+            work_item_id: item.id,
+            kind: item.kind,
+            role,
+            write_allowed: item.write_allowed && narutoRoleAllowsWrite(role)
+        };
+    });
+    const entries = [...counts.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([role, count]) => ({
+        role,
+        count,
+        write_allowed: narutoRoleAllowsWrite(role)
+    }));
+    const implementationLikeWorkers = workItemRoles.filter((row) => NARUTO_IMPLEMENTATION_LIKE_ROLES.has(row.role)).length;
+    const totalWorkers = workItems.length;
+    const implementationLikeRatio = totalWorkers ? implementationLikeWorkers / totalWorkers : 0;
+    const verifierOnly = totalWorkers > 0 && workItemRoles.every((row) => row.role === 'verifier');
+    const writeAllowedCount = workItemRoles.filter((row) => row.write_allowed).length;
+    const blockers = [
+        ...(totalWorkers === 0 ? ['naruto_role_distribution_empty'] : []),
+        ...(!readonly && verifierOnly ? ['naruto_default_must_not_be_verifier_only'] : []),
+        ...(!readonly && implementationLikeRatio < 0.4 ? ['naruto_write_capable_route_requires_40_percent_implementation_like_roles'] : []),
+        ...(!readonly && writeAllowedCount === 0 ? ['naruto_write_capable_route_requires_write_roles'] : [])
+    ];
+    return {
+        schema: 'sks.naruto-role-distribution.v1',
+        readonly,
+        total_workers: totalWorkers,
+        implementation_like_workers: implementationLikeWorkers,
+        implementation_like_ratio: Math.round(implementationLikeRatio * 1000) / 1000,
+        verifier_only: verifierOnly,
+        entries,
+        work_item_roles: workItemRoles,
+        ok: blockers.length === 0,
+        blockers
+    };
+}
+//# sourceMappingURL=naruto-role-policy.js.map

package/dist/core/naruto/naruto-verification-dag.js

@@ -0,0 +1,42 @@
+import { buildVerificationDag } from '../verification/verification-dag.js';
+const NODE_KIND_CYCLE = [
+    'typecheck_shard',
+    'unit_test_shard',
+    'route_gate_shard',
+    'lint_static_scan_shard',
+    'schema_validation_shard',
+    'patch_specific_test_shard',
+    'docs_changelog_check',
+    'side_effect_check',
+    'mutation_ledger_check',
+    'zellij_proof_check',
+    'local_llm_structured_output_check'
+];
+export function buildNarutoVerificationDag(graph, input = {}) {
+    const command = input.command || 'node -e "process.exit(0)"';
+    const verifiableItems = graph.work_items.filter((item) => item.verification_required);
+    const taskIdByWorkItemId = new Map(verifiableItems.map((item, index) => [item.id, `NV-${String(index + 1).padStart(6, '0')}`]));
+    const tasks = verifiableItems
+        .map((item, index) => {
+        const kind = NODE_KIND_CYCLE[index % NODE_KIND_CYCLE.length] || 'route_gate_shard';
+        const taskId = taskIdByWorkItemId.get(item.id) || `NV-${String(index + 1).padStart(6, '0')}`;
+        return {
+            id: taskId,
+            command,
+            ...(input.cwd ? { cwd: input.cwd } : {}),
+            inputs: [...item.target_paths],
+            outputs: [`.sneakoscope/reports/naruto-verification/${item.id}.json`],
+            dependencies: item.dependencies.map((dep) => taskIdByWorkItemId.get(dep)).filter((dep) => typeof dep === 'string' && dep !== taskId),
+            timeout_ms: 60000,
+            read_only: true
+        };
+    });
+    const dag = buildVerificationDag(tasks);
+    return {
+        ...dag,
+        naruto_schema: 'sks.naruto-verification-dag.v1',
+        node_kinds: NODE_KIND_CYCLE,
+        starts_when_dependencies_ready: true
+    };
+}
+//# sourceMappingURL=naruto-verification-dag.js.map

package/dist/core/naruto/naruto-verification-pool.js

@@ -0,0 +1,18 @@
+import { runVerificationDag } from '../verification/verification-worker-pool.js';
+export async function runNarutoVerificationPool(dag, governor, opts = {}) {
+    const safeConcurrency = Math.max(1, governor.verification_parallel);
+    const result = await runVerificationDag(dag, {
+        ...(opts.cwd ? { cwd: opts.cwd } : {}),
+        ...(opts.logDir ? { logDir: opts.logDir } : {}),
+        concurrency: safeConcurrency
+    });
+    return {
+        ...result,
+        naruto_schema: 'sks.naruto-verification-pool.v1',
+        safe_concurrency: safeConcurrency,
+        cpu_heavy_cap_respected: safeConcurrency <= Math.max(1, governor.hardware.cpu_core_count * 2),
+        io_heavy_cap_respected: governor.backpressure !== 'saturated',
+        api_rate_cap_respected: safeConcurrency <= Math.max(1, governor.remote_codex_parallel)
+    };
+}
+//# sourceMappingURL=naruto-verification-pool.js.map

package/dist/core/naruto/naruto-work-graph.js

@@ -0,0 +1,198 @@
+import { mapWorkKindToNarutoRole } from './naruto-role-policy.js';
+import { isNarutoWriteKind, normalizeNarutoPath } from './naruto-work-item.js';
+const WRITE_CAPABLE_KIND_CYCLE = [
+    'implementation',
+    'code_modification',
+    'test_generation',
+    'verification',
+    'research',
+    'documentation',
+    'refactor',
+    'test_execution',
+    'conflict_resolution',
+    'patch_rebase',
+    'rollback_preparation',
+    'integration_support',
+    'final_review_input_pack'
+];
+const READONLY_KIND_CYCLE = [
+    'verification',
+    'research',
+    'test_execution',
+    'ux_review',
+    'ppt_review',
+    'image_review',
+    'final_review_input_pack'
+];
+export function buildNarutoWorkGraph(input = {}) {
+    const requestedClones = normalizePositiveInt(input.requestedClones, 12);
+    const readonly = input.readonly === true;
+    const writeCapable = input.writeCapable !== false && !readonly;
+    const totalWorkItems = Math.max(requestedClones, normalizePositiveInt(input.totalWorkItems, requestedClones));
+    const kindCycle = writeCapable ? WRITE_CAPABLE_KIND_CYCLE : READONLY_KIND_CYCLE;
+    const basePath = normalizeNarutoPath(input.leaseBasePath || '.sneakoscope/naruto/patch-envelopes');
+    const targetPaths = normalizePaths(input.targetPaths || []);
+    const readonlyPaths = normalizePaths(input.readonlyPaths || []);
+    const workItems = [];
+    for (let index = 0; index < totalWorkItems; index += 1) {
+        const id = `NW-${String(index + 1).padStart(6, '0')}`;
+        const kind = kindCycle[index % kindCycle.length] || 'verification';
+        const kindWrites = writeCapable && isNarutoWriteKind(kind);
+        const selectedTarget = targetPaths.length ? targetPaths[index % targetPaths.length] || targetPaths[0] || '' : `${basePath}/${id}.json`;
+        const writePaths = kindWrites ? [selectedTarget].filter(Boolean) : [];
+        const readPaths = readonlyPaths.length ? readonlyPaths : targetPaths.filter((item) => !writePaths.includes(item));
+        const leaseRequirements = [
+            ...writePaths.map((file) => ({ path: file, kind: 'write' })),
+            ...readPaths.map((file) => ({ path: file, kind: 'read' }))
+        ];
+        workItems.push({
+            id,
+            kind,
+            title: titleForKind(kind, id),
+            target_paths: [...new Set([...(writePaths.length ? writePaths : [selectedTarget].filter(Boolean)), ...readPaths])],
+            readonly_paths: readPaths,
+            write_paths: writePaths,
+            required_role: mapWorkKindToNarutoRole(kind),
+            write_allowed: writePaths.length > 0,
+            verification_required: kind !== 'research' && kind !== 'final_review_input_pack',
+            dependencies: dependenciesForKind(kind, workItems),
+            can_run_in_parallel_with: [],
+            conflicts_with: [],
+            estimated_cost: estimateCost(kind),
+            lease_requirements: leaseRequirements,
+            acceptance: {
+                requires_patch_envelope: writePaths.length > 0,
+                requires_verification: kind !== 'research' && kind !== 'final_review_input_pack',
+                requires_gpt_final: writePaths.length > 0 || kind === 'final_review_input_pack'
+            }
+        });
+    }
+    const activeWaves = planNarutoWorkWaves(workItems, Math.max(1, normalizePositiveInt(input.maxActiveWorkers, requestedClones)));
+    annotateParallelCompatibility(workItems, activeWaves);
+    const mixedWorkKinds = [...new Set(workItems.map((item) => item.kind))];
+    const writeAllowedCount = workItems.filter((item) => item.write_allowed).length;
+    const blockers = [
+        ...(mixedWorkKinds.length < 2 ? ['naruto_work_graph_not_mixed'] : []),
+        ...(!readonly && writeAllowedCount === 0 ? ['naruto_write_capable_graph_missing_write_items'] : []),
+        ...(workItems.length < requestedClones ? ['naruto_work_graph_below_requested_clones'] : []),
+        ...activeWaves.flatMap((wave) => wave.conflict_count > 0 ? [`naruto_wave_write_conflict:${wave.wave_id}`] : [])
+    ];
+    return {
+        schema: 'sks.naruto-work-graph.v1',
+        route: '$Naruto',
+        requested_clones: requestedClones,
+        total_work_items: workItems.length,
+        readonly,
+        write_capable: writeCapable,
+        work_items: workItems,
+        active_waves: activeWaves,
+        mixed_work_kinds: mixedWorkKinds,
+        write_allowed_count: writeAllowedCount,
+        ok: blockers.length === 0,
+        blockers
+    };
+}
+export function validateNarutoWorkGraph(graph) {
+    const ids = new Set();
+    const blockers = [...graph.blockers];
+    for (const item of graph.work_items) {
+        if (ids.has(item.id))
+            blockers.push(`duplicate_work_item:${item.id}`);
+        ids.add(item.id);
+        for (const dep of item.dependencies) {
+            if (!ids.has(dep) && !graph.work_items.some((candidate) => candidate.id === dep))
+                blockers.push(`missing_dependency:${item.id}:${dep}`);
+        }
+        if (item.write_allowed && item.acceptance.requires_patch_envelope !== true)
+            blockers.push(`write_item_missing_patch_envelope_acceptance:${item.id}`);
+    }
+    if (graph.total_work_items !== graph.work_items.length)
+        blockers.push('naruto_work_graph_count_mismatch');
+    if (!graph.readonly && graph.write_allowed_count === 0)
+        blockers.push('naruto_write_capable_graph_missing_write_items');
+    return { ok: blockers.length === 0, blockers: [...new Set(blockers)] };
+}
+export function planNarutoWorkWaves(items, maxActiveWorkers) {
+    const pending = [...items];
+    const waves = [];
+    while (pending.length) {
+        const waveItems = [];
+        const writePaths = new Set();
+        for (let index = 0; index < pending.length && waveItems.length < maxActiveWorkers;) {
+            const item = pending[index];
+            if (!item) {
+                index += 1;
+                continue;
+            }
+            const conflicts = item.write_paths.some((file) => writePaths.has(file));
+            if (conflicts) {
+                index += 1;
+                continue;
+            }
+            waveItems.push(item);
+            for (const file of item.write_paths)
+                writePaths.add(file);
+            pending.splice(index, 1);
+        }
+        if (!waveItems.length) {
+            const item = pending.shift();
+            if (item)
+                waveItems.push(item);
+        }
+        const paths = waveItems.flatMap((item) => item.write_paths);
+        waves.push({
+            wave_id: `NWAVE-${String(waves.length + 1).padStart(4, '0')}`,
+            work_item_ids: waveItems.map((item) => item.id),
+            write_paths: [...new Set(paths)],
+            conflict_count: paths.length - new Set(paths).size
+        });
+    }
+    return waves;
+}
+function annotateParallelCompatibility(items, waves) {
+    const byId = new Map(items.map((item) => [item.id, item]));
+    for (const wave of waves) {
+        for (const id of wave.work_item_ids) {
+            const item = byId.get(id);
+            if (!item)
+                continue;
+            item.can_run_in_parallel_with = wave.work_item_ids.filter((other) => other !== id);
+            item.conflicts_with = items
+                .filter((other) => other.id !== id && other.write_paths.some((file) => item.write_paths.includes(file)))
+                .map((other) => other.id);
+        }
+    }
+}
+function dependenciesForKind(kind, previous) {
+    if (kind === 'verification' || kind === 'test_execution') {
+        const candidate = [...previous].reverse().find((item) => item.write_allowed);
+        return candidate ? [candidate.id] : [];
+    }
+    if (kind === 'final_review_input_pack') {
+        return previous.slice(-3).map((item) => item.id);
+    }
+    return [];
+}
+function estimateCost(kind) {
+    const heavy = kind === 'implementation' || kind === 'code_modification' || kind === 'refactor' || kind === 'conflict_resolution';
+    return {
+        tokens: heavy ? 8000 : 3000,
+        latency_ms: heavy ? 90000 : 30000,
+        cpu_weight: kind === 'test_execution' || kind === 'verification' ? 2 : 1,
+        memory_mb: heavy ? 512 : 256,
+        gpu_weight: 0
+    };
+}
+function titleForKind(kind, id) {
+    return `${id} ${kind.replace(/_/g, ' ')}`;
+}
+function normalizePositiveInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return Math.max(1, Math.floor(fallback));
+    return Math.floor(parsed);
+}
+function normalizePaths(paths) {
+    return [...new Set(paths.map(normalizeNarutoPath).filter(Boolean))];
+}
+//# sourceMappingURL=naruto-work-graph.js.map

package/dist/core/naruto/naruto-work-item.js

@@ -0,0 +1,40 @@
+export const NARUTO_WORK_KINDS = [
+    'implementation',
+    'code_modification',
+    'refactor',
+    'test_generation',
+    'test_execution',
+    'verification',
+    'research',
+    'documentation',
+    'ux_review',
+    'ppt_review',
+    'image_review',
+    'conflict_resolution',
+    'patch_rebase',
+    'rollback_preparation',
+    'integration_support',
+    'final_review_input_pack'
+];
+export const NARUTO_WRITE_WORK_KINDS = new Set([
+    'implementation',
+    'code_modification',
+    'refactor',
+    'test_generation',
+    'documentation',
+    'conflict_resolution',
+    'patch_rebase',
+    'rollback_preparation',
+    'integration_support'
+]);
+export function isNarutoWriteKind(kind) {
+    return NARUTO_WRITE_WORK_KINDS.has(kind);
+}
+export function normalizeNarutoWorkKind(value, fallback = 'verification') {
+    const text = String(value || '');
+    return NARUTO_WORK_KINDS.includes(text) ? text : fallback;
+}
+export function normalizeNarutoPath(value) {
+    return String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '').split('/').filter((part) => part && part !== '.').join('/');
+}
+//# sourceMappingURL=naruto-work-item.js.map

package/dist/core/naruto/naruto-work-stealing.js

@@ -0,0 +1,11 @@
+export function stealNarutoWork(queue, input = {}) {
+    const item = queue.shift() || null;
+    return {
+        schema: 'sks.naruto-work-stealing.v1',
+        stolen: Boolean(item),
+        work_item_id: item?.id || null,
+        from_queue: input.fromQueue || 'pending',
+        to_slot: input.toSlot || 'idle-slot'
+    };
+}
+//# sourceMappingURL=naruto-work-stealing.js.map

package/dist/core/naruto/resource-pressure-monitor.js

@@ -0,0 +1,32 @@
+export function monitorNarutoResourcePressure(probe, input = {}) {
+    const activeWorkers = Math.max(1, Math.floor(Number(input.activeWorkers || 1)));
+    const zellijCap = Math.max(1, Math.floor(Number(input.zellijVisiblePaneCap || 12)));
+    const memoryPressure = 1 - (probe.free_memory_bytes / Math.max(1, probe.total_memory_bytes));
+    const cpuPressure = Math.min(1, (probe.current_load_average[0] || 0) / Math.max(1, probe.cpu_core_count));
+    const fdPressure = Math.min(1, (activeWorkers * 6 + probe.process_count) / Math.max(1, probe.file_descriptor_limit));
+    const zellijPressure = Math.min(1, probe.zellij_pane_count / zellijCap);
+    const diskIoPressure = probe.disk_io_pressure;
+    const reasons = [
+        ...(memoryPressure > 0.8 ? ['memory_cap'] : []),
+        ...(cpuPressure > 0.9 ? ['cpu_load_cap'] : []),
+        ...(fdPressure > 0.75 ? ['file_descriptor_budget'] : []),
+        ...(zellijPressure > 0.9 ? ['zellij_ui_pane_budget'] : []),
+        ...(diskIoPressure > 0.75 ? ['disk_io_pressure'] : [])
+    ];
+    const maxPressure = Math.max(memoryPressure, cpuPressure, fdPressure, zellijPressure, diskIoPressure);
+    const state = maxPressure >= 0.92 ? 'saturated' : maxPressure >= 0.72 ? 'throttled' : 'normal';
+    return {
+        schema: 'sks.naruto-resource-pressure.v1',
+        state,
+        memory_pressure: round(memoryPressure),
+        cpu_pressure: round(cpuPressure),
+        fd_pressure: round(fdPressure),
+        zellij_pressure: round(zellijPressure),
+        disk_io_pressure: round(diskIoPressure),
+        reasons
+    };
+}
+function round(value) {
+    return Math.round(Math.max(0, Math.min(1, value)) * 1000) / 1000;
+}
+//# sourceMappingURL=resource-pressure-monitor.js.map

package/dist/core/pipeline/final-gpt-patch-stage.js

@@ -0,0 +1,31 @@
+export function selectFinalGptPatchSource(gptFinal, localPatchEnvelopes = []) {
+    const status = String(gptFinal?.result?.status || gptFinal?.status || '');
+    if (status === 'modified') {
+        return {
+            schema: 'sks.final-gpt-patch-stage.v1',
+            ok: true,
+            final_patch_source: 'gpt_final_arbiter',
+            patch_envelopes: Array.isArray(gptFinal?.result?.modified_patch_envelopes) ? gptFinal.result.modified_patch_envelopes : [],
+            blockers: []
+        };
+    }
+    if (status === 'approved') {
+        return {
+            schema: 'sks.final-gpt-patch-stage.v1',
+            ok: true,
+            final_patch_source: 'gpt_final_arbiter',
+            patch_envelopes: Array.isArray(gptFinal?.result?.accepted_patch_envelopes) && gptFinal.result.accepted_patch_envelopes.length
+                ? gptFinal.result.accepted_patch_envelopes
+                : localPatchEnvelopes,
+            blockers: []
+        };
+    }
+    return {
+        schema: 'sks.final-gpt-patch-stage.v1',
+        ok: false,
+        final_patch_source: 'blocked',
+        patch_envelopes: [],
+        blockers: ['gpt_final_not_approved']
+    };
+}
+//# sourceMappingURL=final-gpt-patch-stage.js.map

package/dist/core/pipeline/final-gpt-review-stage.js

@@ -0,0 +1,5 @@
+import { runGptFinalArbiter } from '../codex-control/gpt-final-arbiter.js';
+export async function runFinalGptReviewStage(input, opts = {}) {
+    return runGptFinalArbiter(input, opts);
+}
+//# sourceMappingURL=final-gpt-review-stage.js.map

package/dist/core/pipeline/finalize-pipeline-result.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { runGptFinalArbiter } from '../codex-control/gpt-final-arbiter.js';
+import { gptFinalRequiredForPipeline } from './gpt-final-required.js';
+export async function finalizePipelineResult(input) {
+    const cwd = path.resolve(input.cwd || process.cwd());
+    const root = path.resolve(input.mutationLedgerRoot || path.join(cwd, '.sneakoscope', 'tmp', 'pipeline-finalize', safeName(input.missionId)));
+    const requirement = gptFinalRequiredForPipeline({
+        localParticipated: input.localParticipated,
+        candidateResults: input.candidateResults
+    });
+    let arbiter = null;
+    let blockers = [];
+    if (requirement.gpt_final_required) {
+        arbiter = await runGptFinalArbiter({
+            schema: 'sks.gpt-final-arbiter-input.v1',
+            route: input.route,
+            mission_id: input.missionId,
+            local_mode: 'local-parallel-gpt-final',
+            local_outputs: input.candidateResults,
+            candidate_patch_envelopes: input.candidatePatchEnvelopes
+        }, {
+            cwd,
+            mutationLedgerRoot: path.join(root, 'gpt-final-arbiter'),
+            ...(typeof input.forceGptFinalUnavailable === 'boolean' ? { forceUnavailable: input.forceGptFinalUnavailable } : {})
+        });
+        blockers = [
+            ...(arbiter.ok ? [] : ['gpt_final_arbiter_required_not_passed']),
+            ...(Array.isArray(arbiter.blockers) ? arbiter.blockers.map(String) : [])
+        ];
+    }
+    const result = {
+        schema: 'sks.pipeline-finalize-result.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        route: input.route,
+        mission_id: input.missionId,
+        local_participated: requirement.local_participated,
+        gpt_final_required: requirement.gpt_final_required,
+        gpt_final_arbiter: arbiter,
+        final_status: blockers.length ? 'blocked' : 'accepted',
+        apply_allowed: blockers.length === 0 && input.applyPatches === true,
+        final_patch_source: requirement.gpt_final_required ? 'gpt_final_arbiter' : 'deterministic_finalize',
+        candidate_results_count: input.candidateResults.length,
+        candidate_patch_envelope_count: input.candidatePatchEnvelopes.length,
+        verification_results_count: input.verificationResults.length,
+        side_effect_report: input.sideEffectReport,
+        mutation_ledger: input.mutationLedger,
+        rollback_plan: input.rollbackPlan,
+        blockers
+    };
+    await writeJsonAtomic(path.join(root, 'pipeline-finalize-result.json'), result);
+    return result;
+}
+function safeName(value) {
+    return String(value || 'unknown').replace(/[^a-zA-Z0-9_.-]+/g, '-').slice(0, 80);
+}
+//# sourceMappingURL=finalize-pipeline-result.js.map

package/dist/core/pipeline/gpt-final-required.js

@@ -0,0 +1,12 @@
+import { localCollaborationParticipated } from '../local-llm/local-collaboration-policy.js';
+export function gptFinalRequiredForPipeline(input) {
+    const localParticipated = input.localParticipated === true
+        || localCollaborationParticipated(Array.isArray(input.candidateResults) ? input.candidateResults : []);
+    return {
+        schema: 'sks.gpt-final-required.v1',
+        local_participated: localParticipated,
+        gpt_final_required: localParticipated,
+        reason: localParticipated ? 'local_llm_outputs_are_drafts' : 'no_local_participation'
+    };
+}
+//# sourceMappingURL=gpt-final-required.js.map

package/dist/core/prompt/prompt-placeholder-guard.js

@@ -0,0 +1,30 @@
+const PLACEHOLDER_PATTERNS = [
+    /@filename\b/i,
+    /<file>/i,
+    /\bTODO_PATH\b/i,
+    /\bINSERT_PATH_HERE\b/i,
+    /\/path\/to\/file\b/i
+];
+export function checkPromptPlaceholders(input = {}) {
+    const prompt = String(input.prompt || '');
+    const writeCapable = input.writeCapable === true;
+    const placeholders = PLACEHOLDER_PATTERNS
+        .filter((pattern) => pattern.test(prompt))
+        .map((pattern) => pattern.source);
+    const emptyTargetPaths = writeCapable && (!Array.isArray(input.targetPaths) || input.targetPaths.length === 0);
+    const blockers = writeCapable ? [
+        ...placeholders.map((placeholder) => `unresolved_prompt_placeholder:${placeholder}`),
+        ...(emptyTargetPaths ? ['write_capable_prompt_target_paths_empty'] : [])
+    ] : [];
+    const warnings = writeCapable ? [] : placeholders.map((placeholder) => `readonly_prompt_placeholder_warning:${placeholder}`);
+    return {
+        schema: 'sks.prompt-placeholder-guard.v1',
+        ok: blockers.length === 0,
+        write_capable: writeCapable,
+        placeholders,
+        empty_target_paths: emptyTargetPaths,
+        blockers,
+        warnings
+    };
+}
+//# sourceMappingURL=prompt-placeholder-guard.js.map

package/dist/core/router/capability-card.js

@@ -1,4 +1,17 @@
 export const DEFAULT_CAPABILITY_CARDS = [
+    {
+        id: 'local-llm-worker',
+        tier: 'worker',
+        supports_images: false,
+        supports_write: true,
+        supports_research: false,
+        reliability: 0.78,
+        latency_cost: 1,
+        token_cost: 0,
+        mutation_risk_cost: 2,
+        model_price_cost: 0,
+        queue_pressure_cost: 2
+    },
     {
         id: 'fast-worker',
         tier: 'worker',

package/dist/core/router/route-cache.js

@@ -8,6 +8,9 @@ export function codexRouteCacheKey(input) {
         files: input.inputFiles || [],
         images: (input.inputImages || []).length,
         sandbox: input.sandboxPolicy,
+        allow_local_llm: input.allowLocalLlm === true,
+        backend_preference: input.backendPreference || [],
+        local_llm_policy: input.localLlmPolicy || null,
         write_paths: input.requestedScopeContract?.write_paths || [],
         allowed_paths: input.requestedScopeContract?.allowed_paths || []
     }));

package/dist/core/router/ultra-router.js

@@ -8,7 +8,8 @@ export function routeCodexTask(input, cards = DEFAULT_CAPABILITY_CARDS) {
         return { ...cached, cache_hit: true };
     const classification = classifyCodexTask(input);
     const hardFilters = [];
-    const scored = cards.map((card) => {
+    const availableCards = input.allowLocalLlm === true ? cards : cards.filter((card) => card.id !== 'local-llm-worker');
+    const scored = availableCards.map((card) => {
         const score = scoreCapabilityCard(card, classification);
         if (score === 0)
             hardFilters.push(card.id);

package/dist/core/routes.js

@@ -371,16 +371,16 @@ export const ROUTES = [
         id: 'Naruto',
         command: '$Naruto',
         mode: 'NARUTO',
-        route: 'shadow clone swarm (high-scale parallel agents)',
-        description: 'Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu): fan out up to 100 parallel clone sessions on the native agent kernel for high-throughput work, with lease-based safe parallel writes, scheduler backfill, and per-clone proof.',
+        route: 'hardware-safe massive parallel work swarm',
+        description: '$Naruto mode launches a hardware-safe massive parallel work swarm. Clones may implement, modify, verify, test, research, document, and resolve conflicts according to role and lease policy; write-capable output is accepted only through patch envelopes, verification DAG, mutation guard, and GPT final arbiter.',
         requiredSkills: ['team', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
         dollarAliases: ['$ShadowClone', '$Kagebunshin'],
         appSkillAliases: ['shadow-clone', 'kage-bunshin'],
-        lifecycle: ['clone_roster_build', 'work_partition', 'parallel_clone_scheduling', 'lease_based_write_swarm', 'per_clone_proof', 'session_cleanup', 'honest_mode'],
+        lifecycle: ['clone_roster_build', 'massive_work_graph', 'hardware_safe_governor', 'dynamic_active_pool', 'lease_based_write_swarm', 'parallel_verification_dag', 'gpt_final_arbiter_pack', 'per_clone_proof', 'session_cleanup', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'high',
         stopGate: 'team-gate.json',
-        cliEntrypoint: 'sks naruto run "task" [--clones N] [--backend codex-exec|fake] | sks naruto status',
+        cliEntrypoint: 'sks naruto run "task" [--clones N] [--backend codex-sdk|fake|ollama] [--parallel-write] | sks naruto status',
         examples: ['$Naruto run sweep the codebase for TODO comments with 50 clones', '$ShadowClone --clones 100 fan out and draft tests for every module']
     },
     {