sneakoscope 5.1.2 → 5.5.0

package/dist/core/agents/agent-orchestrator.js

@@ -842,7 +842,8 @@ function applyNarutoWorkGraphToPartition(partition, graph, roster, targetActiveS
         const writePaths = normalizePathList(item.write_paths);
         const readonlyPaths = normalizePathList(item.readonly_paths);
         const targetPaths = normalizePathList(item.target_paths);
-        const parentObjective = normalizeWorkerPromptText(parentPrompt);
+        const parentObjectiveNormalized = normalizeWorkerPromptText(parentPrompt);
+        const parentObjective = parentObjectiveNormalized.text;
         return Array.from({ length: candidateCount }, (_unused, candidateOffset) => {
             const candidateIndex = candidateOffset + 1;
             const candidateSliceId = candidateCount > 1 ? `${sliceId}-cand${candidateIndex}` : sliceId;
@@ -889,6 +890,9 @@ function applyNarutoWorkGraphToPartition(partition, graph, roster, targetActiveS
                 goal_mode_ref: goalModeRef,
                 strategy_refs: strategyRefs,
                 parent_prompt: parentObjective,
+                worker_prompt_truncated: parentObjectiveNormalized.truncated
+                    ? { worker: owner, dropped_chars: parentObjectiveNormalized.dropped_chars }
+                    : null,
                 max_attempts: 1,
                 description: [
                     parentObjective ? `Parent Naruto objective:\n${parentObjective}` : null,
@@ -2045,8 +2049,16 @@ function buildDirectSdkWorkerPrompt(slice) {
         'Required JSON fields: status, summary, findings, changed_files, patch_envelopes, verification, rollback_notes, blockers.'
     ].join('\n');
 }
+const WORKER_PROMPT_TEXT_MAX_CHARS = 32000;
 function normalizeWorkerPromptText(value) {
-    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, 4000);
+    const normalized = String(value || '').replace(/[^\S\n]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
+    const truncated = normalized.length > WORKER_PROMPT_TEXT_MAX_CHARS;
+    const text = truncated ? normalized.slice(0, WORKER_PROMPT_TEXT_MAX_CHARS) : normalized;
+    return {
+        text,
+        truncated,
+        dropped_chars: truncated ? normalized.length - WORKER_PROMPT_TEXT_MAX_CHARS : 0
+    };
 }
 function buildDirectNoPatchReason(slice, opts) {
     const writePathCount = sdkWritePaths(slice, opts).length;

package/dist/core/agents/agent-proof-evidence.js

@@ -134,6 +134,19 @@ export async function writeAgentProofEvidence(root, input) {
         || (scheduler.pending_queue_drained === true
             && Number(scheduler.active_slot_count || 0) === 0
             && Number(scheduler.max_observed_active_slots || 0) >= Number(scheduler.target_active_slots || 0));
+    const workQueueItems = Array.isArray(workQueue?.items) ? workQueue.items : [];
+    const workItemsNotAllCompletedIds = workQueueItems
+        .filter((item) => item.status !== 'completed')
+        .map((item) => String(item.id));
+    const workItemsFailedOrBlockedCount = Number(scheduler?.failed_count || 0) + Number(scheduler?.blocked_count || 0);
+    const workItemStatusById = new Map(workQueueItems.map((item) => [String(item.id), String(item.status)]));
+    const orphanedPendingWorkItemIds = workQueueItems
+        .filter((item) => item.status === 'pending')
+        .filter((item) => (Array.isArray(item.dependencies) ? item.dependencies : []).some((dep) => {
+        const depStatus = workItemStatusById.get(String(dep));
+        return depStatus === 'failed' || depStatus === 'blocked' || !depStatus;
+    }))
+        .map((item) => String(item.id));
     const blockers = [
         ...(lifecycle.ok ? [] : ['agent_lifecycle_not_all_closed']),
         ...(lifecycle.ok ? [] : lifecycle.open_sessions.map((id) => 'session_open:' + id)),
@@ -154,6 +167,9 @@ export async function writeAgentProofEvidence(root, input) {
         ...(taskGraph && !taskGraphMatchesCliOptions ? ['task_graph_cli_options_mismatch'] : []),
         ...(workQueue && taskGraph && !workQueueMatchesTaskGraph ? ['work_queue_task_graph_mismatch'] : []),
         ...(scheduler && workQueue && !schedulerMatchesWorkQueue ? ['scheduler_work_queue_mismatch'] : []),
+        ...(workQueue && schedulerTotalWorkItems && Number(scheduler?.completed_count || 0) !== schedulerTotalWorkItems ? ['work_items_not_all_completed:' + workItemsNotAllCompletedIds.join(',')] : []),
+        ...(workItemsFailedOrBlockedCount > 0 ? ['work_items_failed:' + workItemsFailedOrBlockedCount] : []),
+        ...(orphanedPendingWorkItemIds.length ? ['work_items_orphaned_pending:' + orphanedPendingWorkItemIds.join(',')] : []),
         ...(taskGraph && !taskGraphSourceRefsOk ? ['task_graph_source_refs_missing'] : []),
         ...(taskGraph && !taskGraphGoalRefsOk ? ['task_graph_goal_refs_missing'] : []),
         ...(taskGraph && !taskGraphStrategyRefsOk ? ['task_graph_strategy_refs_missing'] : []),

package/dist/core/agents/native-cli-worker.js

@@ -327,7 +327,6 @@ function startWorkerProgressTelemetry(input) {
             status: 'running',
             backend: input.backend,
             serviceTier: input.serviceTier,
-            progress: { done: tick, total: 0, label: 'heartbeat' },
             artifacts: [input.heartbeatRel],
             logTail: `backend running ${tick}`
         }).catch(() => undefined);

package/dist/core/bench.js

@@ -121,17 +121,28 @@ export async function runCoreBench(root = process.cwd(), { iterations = 3, tier
     for (const [label, args, commandRoot] of coreCommands(benchTrustMission)) {
         const values = [];
         const failures = [];
+        // TRUST_VALIDATE_BENCH_COMMAND measures latency of `sks trust validate` against a
+        // mock fixture mission. A --mock `$Naruto` run can never satisfy the real agent
+        // gate, so `sks trust validate` legitimately exits 1 (report.ok === false,
+        // status: 'blocked') every time regardless of environment. This row exists to
+        // measure command latency, not to assert the mock mission's trust status, so a
+        // well-formed trust-validation report (valid JSON with the expected schema) is
+        // accepted even on a nonzero exit; only a crash/unparseable-output counts as a
+        // bench failure for this specific command.
+        const acceptNonZeroExit = label === TRUST_VALIDATE_BENCH_COMMAND;
         for (let i = 0; i < CORE_BENCH_WARMUP_ITERATIONS; i += 1) {
             const result = await runBenchProcess(commandRoot || root, script, args);
-            if (result.code !== 0)
+            if (result.code !== 0 && !(acceptNonZeroExit && isWellFormedTrustValidation(result.stdout))) {
                 failures.push({ phase: 'warmup', code: result.code, stderr_tail: result.stderr.slice(-400), stdout_tail: result.stdout.slice(-400) });
+            }
         }
         for (let i = 0; i < measuredIterations; i += 1) {
             const t0 = performance.now();
             const result = await runBenchProcess(commandRoot || root, script, args);
             values.push(performance.now() - t0);
-            if (result.code !== 0)
+            if (result.code !== 0 && !(acceptNonZeroExit && isWellFormedTrustValidation(result.stdout))) {
                 failures.push({ phase: 'measure', code: result.code, stderr_tail: result.stderr.slice(-400), stdout_tail: result.stdout.slice(-400) });
+            }
         }
         const p95 = Math.round(percentile(values, 95));
         rows.push({
@@ -165,8 +176,19 @@ async function runBenchProcess(root, script, args) {
         env: { SKS_SKIP_NPM_FRESHNESS_CHECK: '1', SKS_DISABLE_UPDATE_CHECK: '1', CI: 'true' }
     });
 }
+function isWellFormedTrustValidation(stdout) {
+    const parsed = parseJsonOutput(stdout);
+    return Boolean(parsed && parsed.schema === 'sks.trust-validation.v1' && typeof parsed.status === 'string');
+}
 async function ensureBenchTrustMission(root, script) {
     const benchRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-core-bench-trust-')).catch(() => root);
+    // `sks run` blocks the agent gate (and skips writing completion-proof.json) when
+    // its cwd is not a git repo (git_collaboration.status -> not_git_repo). The bench
+    // trust-mission scratch dir must be a git repo so completion-proof.json/
+    // trust-report.json/run-classification.json actually get written and
+    // hasBenchTrustArtifacts() can find a usable mission instead of falling back to
+    // a nonexistent 'bench-fixture-missing' id (which always fails trust validate).
+    await runProcess('git', ['init', '-q', '.'], { cwd: benchRoot, timeoutMs: 10_000 }).catch(() => null);
     const beforeMissionIds = await listMissionIds(benchRoot);
     const result = await runProcess(process.execPath, [script, 'run', 'fixture', '--mock', '--json'], {
         cwd: benchRoot,