opensquid 0.5.395

package/dist/runtime/auto_correct.js

@@ -0,0 +1,122 @@
+/**
+ * Auto-correct drift policy runtime (AUTO.4).
+ *
+ * Authoritative source: `docs/tasks/automation.md` AUTO.4.
+ *
+ * Lifecycle of an `auto_correct` verdict:
+ *   1. Drift dispatcher emits `RuntimeAction{kind:'auto_correct', correctiveSkill, verdict}`.
+ *   2. Caller invokes `runAutoCorrect()` with pack + evaluator + capability gate
+ *      + a re-eval thunk for the offending rule.
+ *   3. Capability gate fires FIRST (`subagent_call` for `correctiveSkill`).
+ *      Gate denied → no invocation; fall-through descriptor returned.
+ *   4. Corrective skill's process runs via the evaluator. Process error or
+ *      drift verdict from the corrective skill itself → fall-through.
+ *   5. Re-eval original rule. Drift persists → fall-through. Pass → emit a
+ *      "corrected" pass verdict for the audit trail.
+ *
+ * LOOP CAP — 1 ATTEMPT MAX (locked).
+ *   If the corrective skill (or the re-eval) ITSELF produces drift, we do
+ *   NOT recurse — we return a fall-through descriptor so the caller routes
+ *   to `notify_pause` / `escalate`. The cap is structural: no `attemptCount`
+ *   parameter is accepted; there is no second attempt path to count to.
+ *
+ * NO SILENT FAIL-OPEN (C10):
+ *   Every failure mode returns `corrected: false` with a structured
+ *   `fallthrough` descriptor carrying a human-readable reason. The caller
+ *   MUST route this to `notify_pause`. Function never silently swallows.
+ *
+ * Engine-vocabulary: pack / skill / verdict / capability only.
+ */
+import { evaluateProcess } from './evaluator.js';
+/**
+ * Single linear pipeline (no recursion, no retry). Audit reads as: 1
+ * capability check → 1 skill invocation → 1 re-eval → done. Every
+ * fall-through path returns immediately.
+ */
+export async function runAutoCorrect(deps) {
+    const { pack, correctiveSkill, evalCtx, registry, capabilityGate, reevaluateOriginalRule } = deps;
+    // 1. Capability gate FIRST — fail-early before any skill invocation.
+    //    `subagent_call` gates one skill invoking another skill's process.
+    //    Future caps (shell_exec / file_write) inside the corrective skill
+    //    are gated separately by their primitives at process-step time.
+    const gateVerdict = await capabilityGate.check({
+        pack: pack.name,
+        capability: 'subagent_call',
+        target: correctiveSkill,
+    });
+    if (!gateVerdict.allowed) {
+        return fallthrough('capability_denied', `auto_correct denied: capability gate refused subagent_call → "${correctiveSkill}" (${gateVerdict.source})`);
+    }
+    // 2. Resolve the corrective skill from the pack.
+    const skill = findSkill(pack, correctiveSkill);
+    if (!skill) {
+        return fallthrough('corrective_skill_missing', `auto_correct: corrective skill "${correctiveSkill}" not found in pack "${pack.name}"`);
+    }
+    // 3. Invoke the corrective skill's process (track_check rules only;
+    //    destination_check rules need scheduler context).
+    const steps = collectProcessSteps(skill);
+    if (steps.length === 0) {
+        return fallthrough('corrective_skill_missing', `auto_correct: corrective skill "${correctiveSkill}" has no runnable process steps`);
+    }
+    let correctiveResult;
+    try {
+        correctiveResult = await evaluateProcess(steps, evalCtx, registry);
+    }
+    catch (e) {
+        return fallthrough('corrective_skill_error', `auto_correct: corrective skill "${correctiveSkill}" threw: ${String(e)}`);
+    }
+    if (correctiveResult.kind === 'error') {
+        return fallthrough('corrective_skill_error', `auto_correct: corrective skill "${correctiveSkill}" failed at step ${correctiveResult.step}: ${correctiveResult.error}`);
+    }
+    // LOOP CAP — corrective skill itself drifted. Do NOT recurse, do NOT
+    // even re-eval. Surface and stop.
+    if (correctiveResult.kind === 'verdict' && isDriftVerdict(correctiveResult.verdict)) {
+        return fallthrough('corrective_skill_drift', `auto_correct: corrective skill "${correctiveSkill}" itself produced drift (${correctiveResult.verdict.level}): ${correctiveResult.verdict.message}`);
+    }
+    // 4. Re-eval the original rule.
+    let reevalResult;
+    try {
+        reevalResult = await reevaluateOriginalRule();
+    }
+    catch (e) {
+        return fallthrough('reeval_error', `auto_correct: re-eval threw: ${String(e)}`);
+    }
+    if (reevalResult.kind === 'error') {
+        return fallthrough('reeval_error', `auto_correct: re-eval failed at step ${reevalResult.step}: ${reevalResult.error}`);
+    }
+    // LOOP CAP — drift persists. Do NOT auto-correct again.
+    if (reevalResult.kind === 'verdict' && isDriftVerdict(reevalResult.verdict)) {
+        return fallthrough('reeval_persistent_drift', `auto_correct: drift persisted after correction (${reevalResult.verdict.level}): ${reevalResult.verdict.message}`);
+    }
+    // 5. Success — synthetic "corrected" pass verdict for the audit trail.
+    return {
+        corrected: true,
+        correctionVerdict: {
+            level: 'pass',
+            message: `auto_correct: drift resolved by corrective skill "${correctiveSkill}"`,
+            ruleId: deps.verdict.ruleId,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+function fallthrough(kind, reason) {
+    return { corrected: false, correctionVerdict: null, fallthrough: { kind, reason } };
+}
+function findSkill(pack, name) {
+    return pack.skills.find((s) => s.name === name);
+}
+// track_check rules only; destination_check rules need scheduler context.
+function collectProcessSteps(skill) {
+    const out = [];
+    for (const rule of skill.rules) {
+        if (rule.kind === 'track_check')
+            out.push(...rule.process);
+    }
+    return out;
+}
+// "Drift" = anything that isn't a pass.
+function isDriftVerdict(v) {
+    return v.level !== 'pass';
+}
+//# sourceMappingURL=auto_correct.js.map

package/dist/runtime/auto_correct.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto_correct.js","sourceRoot":"","sources":["../../src/runtime/auto_correct.ts"],"names":[],"mappings":"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"}

package/dist/runtime/automation_state.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Automation-mode session flag — file-existence flip for "is this session in
+ * an automation loop right now?" (G.12).
+ *
+ * Flag location: `~/.opensquid/sessions/<session-id>/automation.flag` — sits
+ * alongside `session_state.json` under the same `sessionStateDir(...)` root
+ * so the `OPENSQUID_HOME` test seam extends to it automatically. The file's
+ * contents are intentionally not load-bearing (we only check EXISTENCE), so
+ * we write an ASCII timestamp purely for human-debuggability when poking the
+ * directory by hand.
+ *
+ * Behavior contract:
+ *   - `setAutomationFlag(sessionId)`   — mkdir -p + writeFile (idempotent;
+ *                                        re-setting refreshes the timestamp).
+ *   - `clearAutomationFlag(sessionId)` — unlink; ENOENT swallowed (idempotent).
+ *   - `isAutomationFlagSet(sessionId)` — `fs.stat`; ENOENT → false. ANY other
+ *                                        error also returns false (fail-safe:
+ *                                        a permissions glitch inside a hook
+ *                                        bin should not crash the parent
+ *                                        agent's tool call — we'd rather miss
+ *                                        the automation signal than block).
+ *
+ * The env-var override (`OPENSQUID_AUTOMATION=1`) is checked by the
+ * `is_automation_mode` primitive, NOT here — this module deals only with the
+ * flag-file lifecycle. Both signals OR together at the primitive boundary.
+ *
+ * Imports from: node:fs/promises, node:path, ./paths.js.
+ * Imported by: src/functions/is_automation_mode.ts, src/setup/cli/automation.ts.
+ */
+/** Absolute path to the automation flag file for the given session id. */
+export declare const automationFlagPath: (sessionId: string) => string;
+/** Write the flag file (mkdir -p first). Idempotent. */
+export declare function setAutomationFlag(sessionId: string): Promise<void>;
+/** Remove the flag file. ENOENT is swallowed — idempotent. */
+export declare function clearAutomationFlag(sessionId: string): Promise<void>;
+/**
+ * Returns true iff the flag file exists. ENOENT (and every other stat error)
+ * → false: hooks must NEVER throw at the parent agent over a missing flag.
+ */
+export declare function isAutomationFlagSet(sessionId: string): Promise<boolean>;
+//# sourceMappingURL=automation_state.d.ts.map

package/dist/runtime/automation_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automation_state.d.ts","sourceRoot":"","sources":["../../src/runtime/automation_state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAOH,0EAA0E;AAC1E,eAAO,MAAM,kBAAkB,GAAI,WAAW,MAAM,KAAG,MAIO,CAAC;AAE/D,wDAAwD;AACxD,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIxE;AAED,8DAA8D;AAC9D,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM1E;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO7E"}

package/dist/runtime/automation_state.js

@@ -0,0 +1,68 @@
+/**
+ * Automation-mode session flag — file-existence flip for "is this session in
+ * an automation loop right now?" (G.12).
+ *
+ * Flag location: `~/.opensquid/sessions/<session-id>/automation.flag` — sits
+ * alongside `session_state.json` under the same `sessionStateDir(...)` root
+ * so the `OPENSQUID_HOME` test seam extends to it automatically. The file's
+ * contents are intentionally not load-bearing (we only check EXISTENCE), so
+ * we write an ASCII timestamp purely for human-debuggability when poking the
+ * directory by hand.
+ *
+ * Behavior contract:
+ *   - `setAutomationFlag(sessionId)`   — mkdir -p + writeFile (idempotent;
+ *                                        re-setting refreshes the timestamp).
+ *   - `clearAutomationFlag(sessionId)` — unlink; ENOENT swallowed (idempotent).
+ *   - `isAutomationFlagSet(sessionId)` — `fs.stat`; ENOENT → false. ANY other
+ *                                        error also returns false (fail-safe:
+ *                                        a permissions glitch inside a hook
+ *                                        bin should not crash the parent
+ *                                        agent's tool call — we'd rather miss
+ *                                        the automation signal than block).
+ *
+ * The env-var override (`OPENSQUID_AUTOMATION=1`) is checked by the
+ * `is_automation_mode` primitive, NOT here — this module deals only with the
+ * flag-file lifecycle. Both signals OR together at the primitive boundary.
+ *
+ * Imports from: node:fs/promises, node:path, ./paths.js.
+ * Imported by: src/functions/is_automation_mode.ts, src/setup/cli/automation.ts.
+ */
+import { mkdir, stat, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { sessionStateDir } from './paths.js';
+/** Absolute path to the automation flag file for the given session id. */
+export const automationFlagPath = (sessionId) => 
+// `sessionStateDir` returns `.../sessions/<id>/state`; the flag sits one
+// level up at `.../sessions/<id>/automation.flag` so it's discoverable
+// without colliding with the session_state.json key namespace.
+join(dirname(sessionStateDir(sessionId)), 'automation.flag');
+/** Write the flag file (mkdir -p first). Idempotent. */
+export async function setAutomationFlag(sessionId) {
+    const path = automationFlagPath(sessionId);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${new Date().toISOString()}\n`, 'utf8');
+}
+/** Remove the flag file. ENOENT is swallowed — idempotent. */
+export async function clearAutomationFlag(sessionId) {
+    try {
+        await unlink(automationFlagPath(sessionId));
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+}
+/**
+ * Returns true iff the flag file exists. ENOENT (and every other stat error)
+ * → false: hooks must NEVER throw at the parent agent over a missing flag.
+ */
+export async function isAutomationFlagSet(sessionId) {
+    try {
+        await stat(automationFlagPath(sessionId));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=automation_state.js.map

package/dist/runtime/automation_state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"automation_state.js","sourceRoot":"","sources":["../../src/runtime/automation_state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE1C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,0EAA0E;AAC1E,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,SAAiB,EAAU,EAAE;AAC9D,yEAAyE;AACzE,uEAAuE;AACvE,+DAA+D;AAC/D,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC;AAE/D,wDAAwD;AACxD,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,SAAiB;IACvD,MAAM,IAAI,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC3C,MAAM,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAChD,MAAM,SAAS,CAAC,IAAI,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AACjE,CAAC;AAED,8DAA8D;AAC9D,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,SAAiB;IACzD,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;IAC9C,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,IAAK,CAA2B,CAAC,IAAI,KAAK,QAAQ;YAAE,MAAM,CAAC,CAAC;IAC9D,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,SAAiB;IACzD,IAAI,CAAC;QACH,MAAM,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC"}

package/dist/runtime/bootstrap.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Runtime bootstrap — function registry + active-pack source for hook binaries.
+ *
+ * Two entry points every hook binary imports:
+ *
+ *   - `buildRegistry()` — assembles a `FunctionRegistry` with all primitive
+ *     families registered: event / state / verdict / llm. RAG is NOT
+ *     registered here (see "RAG omission" below).
+ *
+ *   - `loadActivePacks(sessionId)` — Phase 1 test seam. Returns whatever was
+ *     last `setActivePacks(...)`'d in-process, or — for subprocess-launched
+ *     hooks — packs serialized via the `OPENSQUID_TEST_PACK` env var. Phase 2
+ *     replaces this with a real YAML loader that reads `~/.opensquid/active.json`,
+ *     resolves pack sources, parses pack YAML, and respects per-skill load
+ *     modes. The `Promise<Pack[]>` signature is pinned now so the Phase 2
+ *     swap is body-only — call sites do not refactor.
+ *
+ * RAG wiring (T-loop-engine-reintegration / T.3 — first-ever production
+ * registration of recall/embed/store_lesson):
+ *   `registerRagFunctions(registry, backend)` is now called per-bootstrap
+ *   with a backend chosen by `resolveBackendConfig()` (env > config.json >
+ *   default = loop-engine if engine binary discoverable, else libsql-qwen3).
+ *   The cost concerns that justified Phase 1 omission are resolved: the
+ *   default `loop-engine` path connects to a shared UDS daemon (T.4), so
+ *   per-hook boot cost is one socket-connect + one ping, not a full libsql
+ *   open. `buildRegistry()` becomes async to accommodate `backend.init()`
+ *   (engine handshake / libsql CREATE TABLE depending on backend). All
+ *   four hook bins already await it.
+ *
+ * Two env-var test seams (subprocess hook bridge):
+ *
+ *   `OPENSQUID_TEST_PACK` (Phase-1 legacy seam, kept for backward compat):
+ *     A JSON-encoded `Pack` object the child self-seeds at module-load.
+ *     Phase 2.7 keeps this so existing call sites and any in-flight tests
+ *     that hand-build a pack still work. Malformed JSON is silently ignored
+ *     (returns `[]`) — fail-safe, test-only. NEVER document in user docs.
+ *
+ *   `OPENSQUID_TEST_PACK_DIR` (Phase-2.7 seam, preferred):
+ *     An absolute path to an on-disk YAML pack folder (`manifest.yaml` +
+ *     `skills/*\/skill.yaml`). The child invokes the real `loadPack` from
+ *     `src/packs/loader.ts` synchronously at module load via a promise +
+ *     `await` chain handed to `loadActivePacks`. Errors are swallowed at
+ *     the same fail-safe contract as the JSON seam — a missing folder or
+ *     malformed YAML yields `[]`, surfacing as the empty-active-packs
+ *     "allow everything" path. That keeps the seam a strict superset of
+ *     Phase-1 behavior so tests can flip from inline → on-disk without
+ *     changing assertions.
+ *
+ *   Both seams compose: if `OPENSQUID_TEST_PACK_DIR` is set, its loaded
+ *   pack is appended to whatever `OPENSQUID_TEST_PACK` produced. In
+ *   practice tests use exactly one of the two.
+ *
+ * Imports from: functions/, packs/loader.
+ * Imported by: runtime/hooks/*.ts (per-hook binaries), runtime/index.ts (re-export).
+ */
+import { type WedgeLessonStore } from '../rag/wedge/store.js';
+import { FunctionRegistry } from '../functions/registry.js';
+import type { RagBackend } from '../rag/types.js';
+import type { Pack } from './types.js';
+export interface BuildRegistryOpts {
+    /** Inject a pre-built backend (tests). Skips config resolution + init. */
+    backend?: RagBackend;
+    /**
+     * Inject a pre-built wedge lesson store for the lesson primitives (tests).
+     * Production builds construct a fresh `wedgeLessonStore` over libSQL + the
+     * status-dir per-file source (retire-Rust RES-3c — the lesson surface no
+     * longer touches the Rust engine).
+     *
+     * Pass an explicit stub (or `null`) in tests that exercise pure runtime
+     * paths and don't want a real store. `null` disables lesson registration
+     * entirely; `undefined` constructs a fresh store (production default).
+     */
+    lessonStore?: WedgeLessonStore | null;
+}
+export declare function buildRegistry(opts?: BuildRegistryOpts): Promise<FunctionRegistry>;
+export declare function setActivePacks(packs: Pack[]): void;
+/**
+ * Returns the composed active-pack list for this hook subprocess.
+ *
+ * Order: in-process override (`setActivePacks`) wins outright; on top of
+ * that the env-var JSON seam, the disk-YAML seam, and the real on-disk
+ * loader compose by concatenation. Real-loader output is scope-sorted
+ * before concat; test-seam packs preserve insertion order so tests can
+ * assert specific positioning.
+ */
+export declare function loadActivePacks(_sessionId: string): Promise<Pack[]>;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/runtime/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/runtime/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAKH,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAwBhF,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAkB5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,WAAW,iBAAiB;IAChC,0EAA0E;IAC1E,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACvC;AAED,wBAAsB,aAAa,CAAC,IAAI,GAAE,iBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAqI3F;AAkJD,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,CAElD;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAGzE"}