opensquid 0.5.395

package/dist/models/strategies/subscription_cli.js

@@ -0,0 +1,122 @@
+/**
+ * `subscription + cli` strategy: spawn the user's host binary, pipe the
+ * prompt via stdin, capture stdout. The only Phase-1 concrete strategy.
+ *
+ * Model neutrality contract (per `project_opensquid_model_neutral_subagent_primitive`
+ * and the model-name-drift feedback memory): NO vendor identity lives in
+ * this file. `cfg.cli` is the binary name/path supplied by the user's
+ * `models.yaml`; opensquid treats it as an opaque string. The audit-grep
+ * defined in the task spec must return empty against this file.
+ *
+ * Lifecycle:
+ *   1. spawn(cli, args) with stdio: ['pipe', 'pipe', 'pipe']
+ *   2. setTimeout(timeoutMs ?? 30_000) — on fire, SIGTERM the child + reject
+ *   3. write the prompt to stdin and end it (signals EOF to the binary)
+ *   4. accumulate stdout / stderr
+ *   5. on close: clearTimeout; exit 0 → resolve stdout.trim(); else reject
+ *      with stderr-tagged message
+ *
+ * Phase-1 limitation — stdin/stdout deadlock for >64KB prompts:
+ *   Node's pipe stdio uses OS pipe buffers (~64KB on Linux/macOS). For a
+ *   very large prompt, `proc.stdin.write(prompt)` can fill the kernel buffer
+ *   before the child has read enough, and the child may concurrently fill
+ *   its stdout buffer waiting for us to drain — classic mutual-deadlock.
+ *   Phase 1 documents this limit; Phase 2 (cross-cutting LLM track) adds a
+ *   temp-file fallback for prompts above the threshold. Do NOT add a stdin
+ *   `drain` handler here without the temp-file path landing — partial
+ *   mitigations have hidden failure modes.
+ *
+ * Exit-code contract:
+ *   - exit 0   → resolve(stdout.trim())
+ *   - exit ≠ 0 → reject(Error(`exit ${code}: ${stderr.trim()}`))
+ *   - spawn error (ENOENT etc.) → reject via `proc.on('error')`
+ *   - timeout  → SIGTERM + reject(Error('timeout after Xms'))
+ *
+ * Imports from: node:child_process, ../types.js.
+ * Imported by: models/dispatcher.ts.
+ */
+import { spawn } from 'node:child_process';
+const DEFAULT_TIMEOUT_MS = 30_000;
+/**
+ * Typed timeout rejection so callers classify by TYPE, never by message text
+ * (T-AUDIT-SPAWN-FIX — the spawn ledger counts `timeout` vs `error` outcomes).
+ * Message stays byte-identical to the historical `timeout after Xms` string.
+ */
+export class CliTimeoutError extends Error {
+    constructor(timeoutMs) {
+        super(`timeout after ${timeoutMs}ms`);
+        this.name = 'CliTimeoutError';
+    }
+}
+export function subscriptionCliStrategy(cfg) {
+    return {
+        async call(prompt, opts) {
+            if (!cfg.cli) {
+                throw new Error('subscription/cli strategy requires `cli` (the host binary name or path)');
+            }
+            const cliBin = cfg.cli;
+            const args = cfg.args ?? [];
+            const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            return new Promise((resolve, reject) => {
+                const proc = spawn(cliBin, args, {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                let stdout = '';
+                let stderr = '';
+                let settled = false;
+                // Idempotent settlement: spawn-error, exit, and timeout can race
+                // (e.g. timer fires while close is already in flight); first one
+                // wins, the others are no-ops.
+                const settle = (fn) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    fn();
+                };
+                const timer = setTimeout(() => {
+                    // SIGTERM lets the child clean up; if it ignores SIGTERM the
+                    // process leaks until OS kills it — acceptable Phase 1 trade-off
+                    // (the kernel reaps eventually, and we've already rejected the
+                    // promise so the caller is unblocked).
+                    proc.kill('SIGTERM');
+                    settle(() => reject(new CliTimeoutError(timeoutMs)));
+                }, timeoutMs);
+                proc.stdout.on('data', (d) => {
+                    stdout += d.toString('utf8');
+                });
+                proc.stderr.on('data', (d) => {
+                    stderr += d.toString('utf8');
+                });
+                proc.on('error', (e) => {
+                    // ENOENT (cli not on PATH), EACCES (not executable), etc. The
+                    // 'close' event may or may not fire after 'error' — settle here
+                    // to avoid both firing.
+                    settle(() => reject(new Error(`spawn failed: ${e.message}`)));
+                });
+                proc.on('close', (code) => {
+                    settle(() => {
+                        if (code === 0) {
+                            resolve(stdout.trim());
+                        }
+                        else {
+                            reject(new Error(`exit ${code}: ${stderr.trim()}`));
+                        }
+                    });
+                });
+                // stdin.end() flushes the prompt and signals EOF to the binary.
+                // Wrapped in try/catch because the child may have already exited
+                // (e.g. spawn error fired synchronously on Windows) and writing
+                // to a closed stream throws EPIPE.
+                try {
+                    proc.stdin.write(prompt);
+                    proc.stdin.end();
+                }
+                catch (e) {
+                    settle(() => reject(new Error(`stdin write failed: ${String(e)}`)));
+                }
+            });
+        },
+    };
+}
+//# sourceMappingURL=subscription_cli.js.map

package/dist/models/strategies/subscription_cli.js.map

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

package/dist/models/strategies/subscription_sdk.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `subscription + sdk` strategy: in-process Claude Agent SDK call.
+ *
+ * Architectural note (load-bearing):
+ *   This is the ONLY mode that observes parent session state. Mode A
+ *   subagents that need to inherit the parent's context (Phase 6.3) MUST
+ *   route through this strategy — the other modes (cli / api / local /
+ *   mcp) all run out-of-process or hit a remote endpoint and cannot see
+ *   the host's running session. See `project_opensquid_team_modes` and
+ *   `project_opensquid_model_neutral_subagent_primitive` memories.
+ *
+ * Model neutrality (per `feedback_stop_haiku_drift`): NO vendor model name
+ * appears in this file. `cfg.model` is the user-supplied identifier passed
+ * through to the SDK; opensquid treats it as opaque. Audit grep over
+ * `src/models/strategies/*.ts` must return zero hits for `haiku|sonnet|
+ * opus|gpt-[0-9]|claude-[0-9]|gemini` in runtime code.
+ *
+ * Lazy load:
+ *   `@anthropic-ai/claude-agent-sdk` is an OPTIONAL peer dep (Phase 6.2).
+ *   The dynamic import happens at first `.call()` — startup pays nothing
+ *   when the SDK isn't installed. If a user wires `mode: subscription /
+ *   impl: sdk` without the package present, the import throws "Cannot
+ *   find module" and we re-throw with a clearer pointer.
+ *
+ * Test seam (`opts.sdk`):
+ *   Mirrors `src/functions/subagent.ts`. Tests pass `{ sdk }` via the
+ *   factory's second argument to bypass the dynamic import; production
+ *   never sets it. The seam is intentionally NOT a runtime override path
+ *   that pack YAML can reach.
+ *
+ * Imports from: ../types.js.
+ * Imported by: models/dispatcher.ts.
+ */
+import type { ModelAliasConfig, ModelStrategy } from '../types.js';
+export interface SubscriptionSdkRunResult {
+    text: string;
+}
+export interface SubscriptionSdk {
+    runAgent: (opts: {
+        model: string | undefined;
+        prompt: string;
+        timeoutMs: number;
+    }) => Promise<SubscriptionSdkRunResult>;
+}
+export interface SubscriptionSdkOptions {
+    /** Test seam: inject a stub SDK to bypass the lazy dynamic import. */
+    sdk?: SubscriptionSdk;
+}
+export declare function subscriptionSdkStrategy(cfg: ModelAliasConfig, opts?: SubscriptionSdkOptions): ModelStrategy;
+//# sourceMappingURL=subscription_sdk.d.ts.map

package/dist/models/strategies/subscription_sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription_sdk.d.ts","sourceRoot":"","sources":["../../../src/models/strategies/subscription_sdk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAYnE,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,CAAC,IAAI,EAAE;QACf,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;QAC1B,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;KACnB,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,sBAAsB;IACrC,sEAAsE;IACtE,GAAG,CAAC,EAAE,eAAe,CAAC;CACvB;AAoBD,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,gBAAgB,EACrB,IAAI,GAAE,sBAA2B,GAChC,aAAa,CAaf"}

package/dist/models/strategies/subscription_sdk.js

@@ -0,0 +1,65 @@
+/**
+ * `subscription + sdk` strategy: in-process Claude Agent SDK call.
+ *
+ * Architectural note (load-bearing):
+ *   This is the ONLY mode that observes parent session state. Mode A
+ *   subagents that need to inherit the parent's context (Phase 6.3) MUST
+ *   route through this strategy — the other modes (cli / api / local /
+ *   mcp) all run out-of-process or hit a remote endpoint and cannot see
+ *   the host's running session. See `project_opensquid_team_modes` and
+ *   `project_opensquid_model_neutral_subagent_primitive` memories.
+ *
+ * Model neutrality (per `feedback_stop_haiku_drift`): NO vendor model name
+ * appears in this file. `cfg.model` is the user-supplied identifier passed
+ * through to the SDK; opensquid treats it as opaque. Audit grep over
+ * `src/models/strategies/*.ts` must return zero hits for `haiku|sonnet|
+ * opus|gpt-[0-9]|claude-[0-9]|gemini` in runtime code.
+ *
+ * Lazy load:
+ *   `@anthropic-ai/claude-agent-sdk` is an OPTIONAL peer dep (Phase 6.2).
+ *   The dynamic import happens at first `.call()` — startup pays nothing
+ *   when the SDK isn't installed. If a user wires `mode: subscription /
+ *   impl: sdk` without the package present, the import throws "Cannot
+ *   find module" and we re-throw with a clearer pointer.
+ *
+ * Test seam (`opts.sdk`):
+ *   Mirrors `src/functions/subagent.ts`. Tests pass `{ sdk }` via the
+ *   factory's second argument to bypass the dynamic import; production
+ *   never sets it. The seam is intentionally NOT a runtime override path
+ *   that pack YAML can reach.
+ *
+ * Imports from: ../types.js.
+ * Imported by: models/dispatcher.ts.
+ */
+const DEFAULT_TIMEOUT_MS = 30_000;
+async function loadSdk(packageName) {
+    // Variable-string import dodges TS's compile-time module-resolution check.
+    // The SDK is an OPTIONAL peer dep; users who don't enable SDK-mode model
+    // aliases never install it, and that's fine — we only need it on first
+    // `.call()`. A missing install will throw "Cannot find module" here and
+    // surface a useful pointer rather than a silent failure.
+    try {
+        const mod = (await import(/* @vite-ignore */ packageName));
+        return mod;
+    }
+    catch (e) {
+        throw new Error(`subscription/sdk strategy: failed to load SDK package "${packageName}". ` +
+            `Install it (e.g. \`pnpm add ${packageName}\`) or pick a different mode. ` +
+            `Cause: ${String(e)}`);
+    }
+}
+export function subscriptionSdkStrategy(cfg, opts = {}) {
+    return {
+        async call(prompt, callOpts) {
+            const packageName = cfg.sdk ?? '@anthropic-ai/claude-agent-sdk';
+            const sdk = opts.sdk ?? (await loadSdk(packageName));
+            const res = await sdk.runAgent({
+                model: cfg.model,
+                prompt,
+                timeoutMs: callOpts?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            });
+            return res.text;
+        },
+    };
+}
+//# sourceMappingURL=subscription_sdk.js.map

package/dist/models/strategies/subscription_sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription_sdk.js","sourceRoot":"","sources":["../../../src/models/strategies/subscription_sdk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAIH,MAAM,kBAAkB,GAAG,MAAM,CAAC;AA2BlC,KAAK,UAAU,OAAO,CAAC,WAAmB;IACxC,2EAA2E;IAC3E,yEAAyE;IACzE,uEAAuE;IACvE,wEAAwE;IACxE,yDAAyD;IACzD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,CAAC,MAAM,MAAM,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAY,CAAC;QACtE,OAAO,GAAsB,CAAC;IAChC,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CACb,0DAA0D,WAAW,KAAK;YACxE,+BAA+B,WAAW,gCAAgC;YAC1E,UAAU,MAAM,CAAC,CAAC,CAAC,EAAE,CACxB,CAAC;IACJ,CAAC;AACH,CAAC;AAED,MAAM,UAAU,uBAAuB,CACrC,GAAqB,EACrB,OAA+B,EAAE;IAEjC,OAAO;QACL,KAAK,CAAC,IAAI,CAAC,MAAc,EAAE,QAAiC;YAC1D,MAAM,WAAW,GAAG,GAAG,CAAC,GAAG,IAAI,gCAAgC,CAAC;YAChE,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;YACrD,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC,QAAQ,CAAC;gBAC7B,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,MAAM;gBACN,SAAS,EAAE,QAAQ,EAAE,SAAS,IAAI,kBAAkB;aACrD,CAAC,CAAC;YACH,OAAO,GAAG,CAAC,IAAI,CAAC;QAClB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/models/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Model-alias types: the contract a pack's `llm_classify` / `subagent_call`
+ * sees, independent of which backend the user has wired up.
+ *
+ * Architecture (per `project_opensquid_model_neutral_subagent_primitive`):
+ * packs declare ABSTRACT aliases (`fast_classifier`, `narrative_writer`);
+ * the user's `models.yaml` maps each alias to a concrete backend. The
+ * runtime NEVER hardcodes vendor names — every concrete model id or
+ * binary name a vendor would recognise lives in user config only, never
+ * in source.
+ *
+ * Five LLM call modes survive into Phase 1 as a type, but only the
+ * `subscription + cli` strategy is implemented here. The other four
+ * (subscription/sdk, api, local, mcp) are landed in cross-cutting tasks
+ * LLM.1–LLM.4 — until then the dispatcher hands back a stub strategy
+ * that rejects with a "not yet implemented" message naming the mode.
+ *
+ * Imports from: nothing.
+ * Imported by: models/dispatcher.ts, models/strategies/*, models/load_config.ts,
+ *   functions/llm.ts.
+ */
+export type ModelMode = 'subscription' | 'api' | 'local' | 'mcp';
+export type ModelImpl = 'cli' | 'sdk' | undefined;
+export interface ModelAliasConfig {
+    description?: string;
+    mode: ModelMode;
+    impl?: ModelImpl;
+    cli?: string;
+    args?: string[];
+    sdk?: string;
+    model?: string;
+    endpoint?: string;
+    provider?: string;
+    server?: string;
+    tool?: string;
+}
+export interface ModelStrategy {
+    call(prompt: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/models/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/models/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,MAAM,SAAS,GAAG,cAAc,GAAG,KAAK,GAAG,OAAO,GAAG,KAAK,CAAC;AAOjE,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;AAOlD,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,CAAC,EAAE,SAAS,CAAC;IAIjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IAGb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAIlB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAMD,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACtE"}

package/dist/models/types.js

@@ -0,0 +1,23 @@
+/**
+ * Model-alias types: the contract a pack's `llm_classify` / `subagent_call`
+ * sees, independent of which backend the user has wired up.
+ *
+ * Architecture (per `project_opensquid_model_neutral_subagent_primitive`):
+ * packs declare ABSTRACT aliases (`fast_classifier`, `narrative_writer`);
+ * the user's `models.yaml` maps each alias to a concrete backend. The
+ * runtime NEVER hardcodes vendor names — every concrete model id or
+ * binary name a vendor would recognise lives in user config only, never
+ * in source.
+ *
+ * Five LLM call modes survive into Phase 1 as a type, but only the
+ * `subscription + cli` strategy is implemented here. The other four
+ * (subscription/sdk, api, local, mcp) are landed in cross-cutting tasks
+ * LLM.1–LLM.4 — until then the dispatcher hands back a stub strategy
+ * that rejects with a "not yet implemented" message naming the mode.
+ *
+ * Imports from: nothing.
+ * Imported by: models/dispatcher.ts, models/strategies/*, models/load_config.ts,
+ *   functions/llm.ts.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/models/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/models/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG"}

package/dist/origin.d.ts

@@ -0,0 +1,16 @@
+import type { MemoryOrigin } from "./engine-client.js";
+/**
+ * Build a `MemoryOrigin` block describing the current opensquid
+ * process. Called once per `memorize`; cheap (env reads + base
+ * conversions). Returns a typed object with all detected fields
+ * populated; absent fields stay `undefined` so engine-side
+ * `skip_serializing_if = "Option::is_none"` keeps the on-disk YAML
+ * tight.
+ */
+export declare function detectOrigin(): MemoryOrigin;
+/**
+ * Test seam: re-export the stable fallback session id so suites can
+ * assert determinism across calls within one process.
+ */
+export declare function fallbackSessionId(): string;
+//# sourceMappingURL=origin.d.ts.map

package/dist/origin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"origin.d.ts","sourceRoot":"","sources":["../src.legacy/origin.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AA8CvD;;;;;;;GAOG;AACH,wBAAgB,YAAY,IAAI,YAAY,CAU3C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/origin.js

@@ -0,0 +1,92 @@
+/**
+ * Origination metadata auto-detection — v0.4 Phase 1.
+ *
+ * Builds the `MemoryOrigin` block opensquid attaches to every
+ * `memorize` call. The engine treats it as opaque-ish data (typed
+ * struct with all-optional fields); the wedge gate consumes
+ * `session_id` for v0.4+ multi-session reproducibility scoring.
+ *
+ * Detection priority per field:
+ *
+ * - `host`           — `OPENSQUID_HOST` env (explicit override) ->
+ *                      `claude-code` heuristic (CLAUDE_CODE_* / ANTHROPIC_*
+ *                      env presence) -> `unknown`.
+ * - `session_id`     — `CLAUDE_SESSION_ID` env -> fallback opaque
+ *                      `sha1(start_time + pid)[:8]` (stable per
+ *                      process, not per conversation — documented).
+ * - `model`          — `OPENSQUID_MODEL` env -> `ANTHROPIC_MODEL` env ->
+ *                      undefined (omitted).
+ * - `cwd_basename`   — `path.basename(process.cwd())` always.
+ * - `written_at`     — `new Date().toISOString()` always.
+ *
+ * Privacy invariant (mirrors engine-side docs): NEVER emit full file
+ * paths, raw transcript content, or user identity. `session_id` is
+ * opaque — the raw transcript path is hashed before truncation.
+ */
+import { createHash } from "node:crypto";
+import * as path from "node:path";
+/**
+ * Process-lifetime fallback session id. Computed once at module load
+ * so all memorize calls from one opensquid subprocess share the same
+ * id when no host-provided id is available.
+ */
+const FALLBACK_SESSION_ID = computeFallbackSessionId();
+function computeFallbackSessionId() {
+    const seed = `${Date.now()}.${process.pid}.${Math.random()}`;
+    return createHash("sha1").update(seed).digest("hex").slice(0, 8);
+}
+function detectHost() {
+    if (process.env.OPENSQUID_HOST)
+        return process.env.OPENSQUID_HOST;
+    // Claude Code exposes a handful of CLAUDE_* env vars when it spawns
+    // an MCP child. Probe for any of them as a soft signal.
+    if (process.env.CLAUDE_CODE_VERSION ||
+        process.env.CLAUDE_PROJECT_DIR ||
+        process.env.CLAUDE_SESSION_ID) {
+        return "claude-code";
+    }
+    return "unknown";
+}
+function detectSessionId() {
+    const raw = process.env.CLAUDE_SESSION_ID?.trim();
+    if (raw) {
+        // Hash + truncate so the on-disk id is opaque (not the raw UUID
+        // visible elsewhere on the system). Privacy invariant.
+        return createHash("sha1").update(raw).digest("hex").slice(0, 8);
+    }
+    return FALLBACK_SESSION_ID;
+}
+function detectModel() {
+    return process.env.OPENSQUID_MODEL?.trim() || process.env.ANTHROPIC_MODEL?.trim() || undefined;
+}
+function detectCwdBasename() {
+    return path.basename(process.cwd());
+}
+/**
+ * Build a `MemoryOrigin` block describing the current opensquid
+ * process. Called once per `memorize`; cheap (env reads + base
+ * conversions). Returns a typed object with all detected fields
+ * populated; absent fields stay `undefined` so engine-side
+ * `skip_serializing_if = "Option::is_none"` keeps the on-disk YAML
+ * tight.
+ */
+export function detectOrigin() {
+    const origin = {
+        host: detectHost(),
+        session_id: detectSessionId(),
+        cwd_basename: detectCwdBasename(),
+        written_at: new Date().toISOString(),
+    };
+    const model = detectModel();
+    if (model)
+        origin.model = model;
+    return origin;
+}
+/**
+ * Test seam: re-export the stable fallback session id so suites can
+ * assert determinism across calls within one process.
+ */
+export function fallbackSessionId() {
+    return FALLBACK_SESSION_ID;
+}
+//# sourceMappingURL=origin.js.map

package/dist/origin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"origin.js","sourceRoot":"","sources":["../src.legacy/origin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAIlC;;;;GAIG;AACH,MAAM,mBAAmB,GAAG,wBAAwB,EAAE,CAAC;AAEvD,SAAS,wBAAwB;IAC/B,MAAM,IAAI,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;IAC7D,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACnE,CAAC;AAED,SAAS,UAAU;IACjB,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc;QAAE,OAAO,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;IAClE,oEAAoE;IACpE,wDAAwD;IACxD,IACE,OAAO,CAAC,GAAG,CAAC,mBAAmB;QAC/B,OAAO,CAAC,GAAG,CAAC,kBAAkB;QAC9B,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAC7B,CAAC;QACD,OAAO,aAAa,CAAC;IACvB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,eAAe;IACtB,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,IAAI,EAAE,CAAC;IAClD,IAAI,GAAG,EAAE,CAAC;QACR,gEAAgE;QAChE,uDAAuD;QACvD,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,SAAS,WAAW;IAClB,OAAO,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,SAAS,CAAC;AACjG,CAAC;AAED,SAAS,iBAAiB;IACxB,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY;IAC1B,MAAM,MAAM,GAAiB;QAC3B,IAAI,EAAE,UAAU,EAAE;QAClB,UAAU,EAAE,eAAe,EAAE;QAC7B,YAAY,EAAE,iBAAiB,EAAE;QACjC,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;KACrC,CAAC;IACF,MAAM,KAAK,GAAG,WAAW,EAAE,CAAC;IAC5B,IAAI,KAAK;QAAE,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;IAChC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,mBAAmB,CAAC;AAC7B,CAAC"}

package/dist/packs/apply_extends.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `extends:` mechanism — layer a child pack over a parent without forking.
+ *
+ * Per `docs/opensquid-real-design.md` §"Manifest fields" (`extends` row) and
+ * §"Conflict resolution policy". `extends:` is the EXPLICIT override path:
+ * the user opts into "child wins on field collision, child skills override
+ * parent skills by name" rather than letting the runtime silently pick a
+ * winner. It is the named alternative to the forbidden auto-resolve.
+ *
+ * Merge semantics (locked):
+ *   - Top-level scalar fields (name, version, scope, goal, description,
+ *     `extends`) — child value replaces parent value. `description` falls
+ *     back to parent only when the child supplied the empty string default
+ *     (so an "I forgot to write one" child doesn't blank out a real parent
+ *     description); explicit child string wins.
+ *   - List fields (requires, conflicts) — child REPLACES parent. Union
+ *     semantics would silently re-introduce parent dependencies a child
+ *     wanted to drop; replacement keeps `extends:` predictable.
+ *   - `evolves` — child wins. A child that wants the wedge gate off needs
+ *     to be able to turn it off regardless of parent default.
+ *   - `skills` — merged by `name`. Same-named skill in child replaces
+ *     parent's; new skills append; parent-only skills carry through.
+ *
+ * Defensive deep-clone: `JSON.parse(JSON.stringify(parent))` strips Dates,
+ * RegExps, functions, and `undefined`. `Pack` is data-only (Zod-validated
+ * plain objects with strings / numbers / booleans / nested objects / arrays),
+ * so the round-trip is lossless. Documented here so a future field addition
+ * doesn't accidentally break the contract — adding a `Date` field to `Pack`
+ * means choosing a different clone strategy. Cloning the PARENT (not the
+ * child) is intentional: the parent provides the base structure, and we
+ * spend most of the merge code mutating that clone with child values.
+ *
+ * `detectExtendsCycle` walks the `extends` chain starting from each pack
+ * and flags any pack whose chain re-enters itself. Returns the set of
+ * cycle-START names; callers (validation layer) decide whether to error
+ * or surface to the user. Out-of-scope: `extends:` pointing at a missing
+ * parent — that's a validation concern, not a cycle concern; the caller
+ * (loader) handles missing parents before invoking this function.
+ *
+ * Imports from: runtime/types.ts (Pack).
+ * Imported by: future load-orchestrator (Phase 5 integration); re-exported
+ * via packs/index.ts.
+ */
+import type { Pack } from '../runtime/types.js';
+export declare function applyExtends(child: Pack, parent: Pack): Pack;
+export declare function detectExtendsCycle(packs: Pack[]): string[];
+//# sourceMappingURL=apply_extends.d.ts.map

package/dist/packs/apply_extends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply_extends.d.ts","sourceRoot":"","sources":["../../src/packs/apply_extends.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD,wBAAgB,YAAY,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,IAAI,CAkC5D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,CAqB1D"}

package/dist/packs/apply_extends.js

@@ -0,0 +1,96 @@
+/**
+ * `extends:` mechanism — layer a child pack over a parent without forking.
+ *
+ * Per `docs/opensquid-real-design.md` §"Manifest fields" (`extends` row) and
+ * §"Conflict resolution policy". `extends:` is the EXPLICIT override path:
+ * the user opts into "child wins on field collision, child skills override
+ * parent skills by name" rather than letting the runtime silently pick a
+ * winner. It is the named alternative to the forbidden auto-resolve.
+ *
+ * Merge semantics (locked):
+ *   - Top-level scalar fields (name, version, scope, goal, description,
+ *     `extends`) — child value replaces parent value. `description` falls
+ *     back to parent only when the child supplied the empty string default
+ *     (so an "I forgot to write one" child doesn't blank out a real parent
+ *     description); explicit child string wins.
+ *   - List fields (requires, conflicts) — child REPLACES parent. Union
+ *     semantics would silently re-introduce parent dependencies a child
+ *     wanted to drop; replacement keeps `extends:` predictable.
+ *   - `evolves` — child wins. A child that wants the wedge gate off needs
+ *     to be able to turn it off regardless of parent default.
+ *   - `skills` — merged by `name`. Same-named skill in child replaces
+ *     parent's; new skills append; parent-only skills carry through.
+ *
+ * Defensive deep-clone: `JSON.parse(JSON.stringify(parent))` strips Dates,
+ * RegExps, functions, and `undefined`. `Pack` is data-only (Zod-validated
+ * plain objects with strings / numbers / booleans / nested objects / arrays),
+ * so the round-trip is lossless. Documented here so a future field addition
+ * doesn't accidentally break the contract — adding a `Date` field to `Pack`
+ * means choosing a different clone strategy. Cloning the PARENT (not the
+ * child) is intentional: the parent provides the base structure, and we
+ * spend most of the merge code mutating that clone with child values.
+ *
+ * `detectExtendsCycle` walks the `extends` chain starting from each pack
+ * and flags any pack whose chain re-enters itself. Returns the set of
+ * cycle-START names; callers (validation layer) decide whether to error
+ * or surface to the user. Out-of-scope: `extends:` pointing at a missing
+ * parent — that's a validation concern, not a cycle concern; the caller
+ * (loader) handles missing parents before invoking this function.
+ *
+ * Imports from: runtime/types.ts (Pack).
+ * Imported by: future load-orchestrator (Phase 5 integration); re-exported
+ * via packs/index.ts.
+ */
+export function applyExtends(child, parent) {
+    // Deep-clone parent so the merged result shares no reference with either
+    // input. Caller can mutate `merged` freely without leaking back. See
+    // file-level comment for why JSON round-trip is the right clone choice
+    // for a data-only schema.
+    const merged = JSON.parse(JSON.stringify(parent));
+    // Child wins on top-level scalars. `description` keeps parent ONLY when
+    // child supplied the empty-string default; an explicit child "" would be
+    // unusual but a non-empty explicit child string always wins.
+    merged.name = child.name;
+    merged.version = child.version;
+    merged.scope = child.scope;
+    merged.goal = child.goal;
+    merged.description = child.description !== '' ? child.description : merged.description;
+    merged.extends = child.extends;
+    merged.evolves = child.evolves;
+    // Lists replace, don't union. Spread to defensive-copy in case the child
+    // is later mutated by a caller — `merged.requires === child.requires`
+    // would create a shared reference and reintroduce mutation hazards.
+    merged.requires = [...child.requires];
+    merged.conflicts = [...child.conflicts];
+    // Skills: merge by name. Map seed from parent (already cloned), then
+    // every child skill overwrites or appends. Iteration order of the final
+    // Map is insertion-order: parent-only skills first, then any
+    // child-added new names in child's declared order, with overridden names
+    // retaining their parent position.
+    const skillMap = new Map(merged.skills.map((s) => [s.name, s]));
+    for (const s of child.skills)
+        skillMap.set(s.name, s);
+    merged.skills = [...skillMap.values()];
+    return merged;
+}
+export function detectExtendsCycle(packs) {
+    const byName = new Map(packs.map((p) => [p.name, p]));
+    const cycles = [];
+    // Each pack starts its own walk. Self-extends counts as a cycle the moment
+    // the walker re-visits the starting node. We track `visited` per-start so
+    // legitimate diamond-shape chains (A→B, C→B) don't false-positive.
+    for (const start of packs) {
+        const visited = new Set();
+        let cur = start;
+        while (cur?.extends) {
+            if (visited.has(cur.name)) {
+                cycles.push(start.name);
+                break;
+            }
+            visited.add(cur.name);
+            cur = byName.get(cur.extends);
+        }
+    }
+    return cycles;
+}
+//# sourceMappingURL=apply_extends.js.map

package/dist/packs/apply_extends.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply_extends.js","sourceRoot":"","sources":["../../src/packs/apply_extends.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAIH,MAAM,UAAU,YAAY,CAAC,KAAW,EAAE,MAAY;IACpD,yEAAyE;IACzE,qEAAqE;IACrE,uEAAuE;IACvE,0BAA0B;IAC1B,MAAM,MAAM,GAAS,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAS,CAAC;IAEhE,wEAAwE;IACxE,yEAAyE;IACzE,6DAA6D;IAC7D,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACzB,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IAC/B,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAC3B,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACzB,MAAM,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC;IACvF,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IAC/B,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IAE/B,yEAAyE;IACzE,sEAAsE;IACtE,oEAAoE;IACpE,MAAM,CAAC,QAAQ,GAAG,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC;IACtC,MAAM,CAAC,SAAS,GAAG,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;IAExC,qEAAqE;IACrE,wEAAwE;IACxE,6DAA6D;IAC7D,yEAAyE;IACzE,mCAAmC;IACnC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAChE,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,MAAM;QAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACtD,MAAM,CAAC,MAAM,GAAG,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IAEvC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,2EAA2E;IAC3E,0EAA0E;IAC1E,mEAAmE;IACnE,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;QAC1B,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;QAClC,IAAI,GAAG,GAAqB,KAAK,CAAC;QAClC,OAAO,GAAG,EAAE,OAAO,EAAE,CAAC;YACpB,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC1B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBACxB,MAAM;YACR,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACtB,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/packs/composite_resolver.d.ts

@@ -0,0 +1,14 @@
+import type { Pack } from '../runtime/types.js';
+export declare const MAX_COMPOSITE_DEPTH = 3;
+export declare class CompositeResolutionError extends Error {
+    readonly compositePack: string;
+    readonly cause?: string | undefined;
+    constructor(message: string, compositePack: string, cause?: string | undefined);
+}
+/**
+ * Expand composite packs into their includes. Returns the flat list per the
+ * module-header contract. Throws `CompositeResolutionError` on cycle,
+ * depth-exceeded, missing include, semver-mismatch, or invalid-semver.
+ */
+export declare function expandComposites(packs: readonly Pack[]): Pack[];
+//# sourceMappingURL=composite_resolver.d.ts.map

package/dist/packs/composite_resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite_resolver.d.ts","sourceRoot":"","sources":["../../src/packs/composite_resolver.ts"],"names":[],"mappings":"AA+CA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,qBAAa,wBAAyB,SAAQ,KAAK;aAG/B,aAAa,EAAE,MAAM;aACrB,KAAK,CAAC,EAAE,MAAM;gBAF9B,OAAO,EAAE,MAAM,EACC,aAAa,EAAE,MAAM,EACrB,KAAK,CAAC,EAAE,MAAM,YAAA;CAKjC;AAQD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,EAAE,CA4B/D"}