synergyspec-selfevolving 1.3.0 → 1.4.0

package/dist/core/trajectory/skeleton.d.ts

@@ -0,0 +1,43 @@
+import type { HarnessName, NormalizedTrajectory } from './model.js';
+export interface SkeletonEvent {
+    kind: 'file-edit' | 'test-run' | 'command';
+    /** 0-based position in the (post-rollup, pre-truncation) event sequence. */
+    ordinal: number;
+    /** Tool name as the harness reports it. */
+    tool: string;
+    /** POSIX-normalized file path (file-edit only). */
+    file?: string;
+    /** How many consecutive edits to `file` this event rolls up (file-edit only). */
+    editCount?: number;
+    /** Executed command line, capped (test-run / command only). */
+    command?: string;
+    /** Exit code of the paired result, when structured (test-run / command). */
+    exitCode?: number | null;
+    /** Pass rate parsed from the paired runner output (test-run only). */
+    passRate?: number | null;
+    /** Failed-test count parsed from the paired runner output (test-run only). */
+    failedCount?: number | null;
+    /** Session that produced the event (main or subagent). */
+    sessionId?: string;
+}
+export interface ActionSkeleton {
+    harness: HarnessName;
+    /** Ordered, rolled-up, bounded events (≤ {@link MAX_SKELETON_EVENTS}). */
+    events: SkeletonEvent[];
+    /** Total tool_call parts seen (pre-projection activity signal). */
+    totalToolCalls: number;
+    /** True when events were middle-out truncated to the cap. */
+    truncated: boolean;
+}
+/**
+ * Project the bounded action skeleton from a normalized trajectory. One walk,
+ * the same call→result pairing approach as facts.ts's collectRunnerResults
+ * (callId map with a positional fallback).
+ */
+export declare function toActionSkeleton(trajectory: NormalizedTrajectory | null): ActionSkeleton | null;
+/**
+ * Human-readable one-line(ish) play-by-play. Deterministic; events are dropped
+ * middle-out (with an elision marker) until the string fits `maxChars`.
+ */
+export declare function renderActionSkeleton(skeleton: ActionSkeleton, maxChars?: number): string;
+//# sourceMappingURL=skeleton.d.ts.map

package/dist/core/trajectory/skeleton.js

@@ -0,0 +1,239 @@
+/**
+ * Action-skeleton projection: a BOUNDED, ordered play-by-play of what the agent
+ * actually did in the observed run — `wrote design.md → ran tests: 3 failed →
+ * edited normalize.py (x4) → ran tests: 0 failed`.
+ *
+ * This is the trajectory the critic reads. It is deliberately a PROJECTION of
+ * the same window-scoped {@link NormalizedTrajectory} the observed-verified
+ * gate grades (one shared implementation over the normalized shape — never
+ * per-adapter, so the three harnesses cannot drift), and deliberately lossy:
+ * only file edits, test runs, and other shell commands survive; reads, prose,
+ * and reasoning are dropped. Ordering is the stitched turn order (main session
+ * first, then subagents) — the exact order `collectRunnerResults` grades in.
+ *
+ * Pure + no throw. `null` in → `null` out.
+ */
+import { parseTestMetrics } from '../fitness/test-metrics.js';
+import { commandText, inputLooksLikeRunner, isExecTool } from './facts.js';
+const MAX_SKELETON_EVENTS = 40;
+const MAX_COMMAND_CHARS = 120;
+/**
+ * Matches the NAME of a file-mutating tool across harnesses — Claude
+ * `Write`/`Edit`/`MultiEdit`/`NotebookEdit`; opencode `write`/`edit`/`patch`;
+ * Codex `apply_patch`; generic `str_replace`/`create_file` variants. Deny by
+ * default (same philosophy as facts.ts's EXEC_TOOL_RE): an unrecognized tool
+ * name degrades to "event skipped", never to a phantom edit. Word-boundaried
+ * on `._-`; `multiedit`/`notebookedit` are single lowercase tokens after
+ * `.toLowerCase()`, so they are listed explicitly.
+ */
+const EDIT_TOOL_RE = /(?:^|[._-])(?:write|edit|multiedit|notebookedit|patch|apply_patch|str_replace|replace|create|update)(?:[._-]|$)/i;
+/** Input fields that carry the edited file path, in preference order. */
+const FILE_FIELDS = ['file_path', 'filePath', 'path', 'notebook_path', 'notebookPath'];
+/** `*** (Add|Update|Delete) File: <path>` lines inside an apply_patch payload. */
+const PATCH_FILE_RE = /^\*{3}\s+(?:Add|Update|Delete)\s+File:\s+(.+)$/gm;
+function toPosix(p) {
+    return p.replace(/\\/g, '/').trim();
+}
+function isEditTool(tool) {
+    return tool !== undefined && EDIT_TOOL_RE.test(tool);
+}
+/** `*** … File:` paths inside an apply_patch-style payload (markers only). */
+function patchFilesFromPayload(input) {
+    if (!input)
+        return [];
+    const files = [];
+    for (const value of Object.values(input)) {
+        if (typeof value !== 'string')
+            continue;
+        for (const m of value.matchAll(PATCH_FILE_RE))
+            files.push(toPosix(m[1]));
+    }
+    return files;
+}
+/**
+ * Extract the edited file path(s) from a FILE-tool call's input: a path field
+ * first, else patch-body markers. Never used for exec tools — their inputs
+ * legitimately carry `path`-like fields (cwd) that are not edits.
+ */
+function editedFiles(input) {
+    if (!input)
+        return [];
+    for (const f of FILE_FIELDS) {
+        const v = input[f];
+        if (typeof v === 'string' && v.trim().length > 0)
+            return [toPosix(v)];
+    }
+    return patchFilesFromPayload(input);
+}
+function capCommand(command) {
+    if (!command)
+        return undefined;
+    const c = command.trim().replace(/\s+/g, ' ');
+    return c.length > MAX_COMMAND_CHARS ? `${c.slice(0, MAX_COMMAND_CHARS - 1)}…` : c;
+}
+/**
+ * Project the bounded action skeleton from a normalized trajectory. One walk,
+ * the same call→result pairing approach as facts.ts's collectRunnerResults
+ * (callId map with a positional fallback).
+ */
+export function toActionSkeleton(trajectory) {
+    if (!trajectory)
+        return null;
+    const pendingByCallId = new Map();
+    let lastPending = null;
+    let totalToolCalls = 0;
+    const events = [];
+    const append = (event) => {
+        // Per-file rollup: consecutive edits to the same file collapse.
+        const prev = events[events.length - 1];
+        if (event.kind === 'file-edit' &&
+            prev?.kind === 'file-edit' &&
+            prev.file === event.file &&
+            prev.sessionId === event.sessionId) {
+            prev.editCount = (prev.editCount ?? 1) + 1;
+            return prev;
+        }
+        events.push(event);
+        return event;
+    };
+    for (const turn of trajectory.turns) {
+        for (const part of turn.parts) {
+            if (part.kind === 'tool_call') {
+                totalToolCalls++;
+                const exec = isExecTool(part.tool);
+                if (exec) {
+                    const command = capCommand(commandText(part.input));
+                    // A shell-driven apply_patch (codex heredoc style) carries
+                    // `*** Update File: <path>` lines in its payload — that's a file
+                    // edit, not a command. Markers only: an exec input's `path`-like
+                    // fields (cwd) must never read as edits.
+                    const patchedFiles = patchFilesFromPayload(part.input);
+                    if (patchedFiles.length > 0) {
+                        for (const file of patchedFiles) {
+                            append({
+                                kind: 'file-edit',
+                                ordinal: 0,
+                                tool: part.tool,
+                                file,
+                                editCount: 1,
+                                ...(turn.sessionId ? { sessionId: turn.sessionId } : {}),
+                            });
+                        }
+                        lastPending = null;
+                        continue;
+                    }
+                    const event = append({
+                        kind: inputLooksLikeRunner(part.input) ? 'test-run' : 'command',
+                        ordinal: 0,
+                        tool: part.tool,
+                        ...(command ? { command } : {}),
+                        ...(turn.sessionId ? { sessionId: turn.sessionId } : {}),
+                    });
+                    const pending = { event };
+                    lastPending = pending;
+                    if (part.callId)
+                        pendingByCallId.set(part.callId, pending);
+                    continue;
+                }
+                if (isEditTool(part.tool)) {
+                    for (const file of editedFiles(part.input)) {
+                        append({
+                            kind: 'file-edit',
+                            ordinal: 0,
+                            tool: part.tool,
+                            file,
+                            editCount: 1,
+                            ...(turn.sessionId ? { sessionId: turn.sessionId } : {}),
+                        });
+                    }
+                }
+                lastPending = null;
+            }
+            else if (part.kind === 'tool_result') {
+                const pending = part.callId && pendingByCallId.has(part.callId)
+                    ? pendingByCallId.get(part.callId)
+                    : !part.callId && lastPending
+                        ? lastPending
+                        : undefined;
+                if (pending) {
+                    const e = pending.event;
+                    if (typeof part.exitCode === 'number')
+                        e.exitCode = part.exitCode;
+                    if (e.kind === 'test-run' && typeof part.output === 'string') {
+                        const metrics = parseTestMetrics(part.output);
+                        if (metrics) {
+                            e.passRate = metrics.passRate;
+                            e.failedCount = metrics.failed;
+                        }
+                    }
+                }
+                lastPending = null;
+            }
+        }
+    }
+    // Stamp ordinals on the full (rolled-up) sequence, then middle-out truncate.
+    events.forEach((e, i) => {
+        e.ordinal = i;
+    });
+    let bounded = events;
+    let truncated = false;
+    if (events.length > MAX_SKELETON_EVENTS) {
+        const head = Math.ceil(MAX_SKELETON_EVENTS / 2);
+        const tail = MAX_SKELETON_EVENTS - head;
+        bounded = [...events.slice(0, head), ...events.slice(events.length - tail)];
+        truncated = true;
+    }
+    return {
+        harness: trajectory.harness,
+        events: bounded,
+        totalToolCalls,
+        truncated,
+    };
+}
+function basename(p) {
+    const parts = p.split('/');
+    return parts[parts.length - 1] || p;
+}
+function renderEvent(e) {
+    if (e.kind === 'file-edit') {
+        const verb = /(?:^|[._-])(?:write|create)(?:[._-]|$)/i.test(e.tool) ? 'wrote' : 'edited';
+        const times = (e.editCount ?? 1) > 1 ? ` (x${e.editCount})` : '';
+        return `${verb} ${basename(e.file ?? '?')}${times}`;
+    }
+    if (e.kind === 'test-run') {
+        if (typeof e.failedCount === 'number') {
+            return `ran tests: ${e.failedCount} failed`;
+        }
+        if (typeof e.exitCode === 'number') {
+            return `ran tests (exit ${e.exitCode})`;
+        }
+        return 'ran tests';
+    }
+    return e.command ? `ran \`${e.command}\`` : `ran ${e.tool}`;
+}
+/**
+ * Human-readable one-line(ish) play-by-play. Deterministic; events are dropped
+ * middle-out (with an elision marker) until the string fits `maxChars`.
+ */
+export function renderActionSkeleton(skeleton, maxChars = 1600) {
+    if (skeleton.events.length === 0)
+        return '(no file edits or shell commands observed)';
+    let omitted = skeleton.truncated ? 1 : 0; // marker for projection-time truncation
+    let items = skeleton.events.map(renderEvent);
+    const join = (parts, elided) => {
+        if (elided <= 0)
+            return parts.join(' → ');
+        const head = parts.slice(0, Math.ceil(parts.length / 2));
+        const tail = parts.slice(Math.ceil(parts.length / 2));
+        return `${head.join(' → ')} → … → ${tail.join(' → ')}`;
+    };
+    let text = join(items, omitted);
+    while (text.length > maxChars && items.length > 2) {
+        // Drop the middle event and re-join with an elision marker.
+        items = [...items.slice(0, Math.floor(items.length / 2)), ...items.slice(Math.floor(items.length / 2) + 1)];
+        omitted++;
+        text = join(items, omitted);
+    }
+    return text.length > maxChars ? `${text.slice(0, maxChars - 1)}…` : text;
+}
+//# sourceMappingURL=skeleton.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synergyspec-selfevolving",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "synergyspec-selfevolving",
@@ -38,6 +38,7 @@
     "scripts/postinstall.js",
     "scripts/nl2repo_synergyspec-selfevolving_wrapper.py",
     "scripts/code-health.py",
+    "scripts/slop_rules.yaml",
     "!dist/**/*.test.js",
     "!dist/**/__tests__",
     "!dist/**/*.map"
@@ -79,6 +80,7 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
+    "@ast-grep/cli": "0.43.0",
     "@inquirer/core": "^10.2.2",
     "@inquirer/prompts": "^7.8.0",
     "ansi-regex": "^5.0.1",