@davesheffer/hunch 1.29.0 → 1.31.0

package/dist/store/stateBinding.js

@@ -26,7 +26,7 @@ import { decisionId } from "../core/ids.js";
 import { ENTITY_KINDS, SCHEMAS } from "../core/types.js";
 import { captureConflicts, isLive } from "../core/topics.js";
 import { buildDeliveryEnvelope } from "../core/delivery.js";
-import { STATE_CAPABILITIES, STATE_CONTRACT_VERSION, STATE_FACETS, STATE_READ_VERSION, STATE_SUBSCRIBE_VERSION, STATE_WRITE_VERSION, ReadRequestSchema, ReadResponseSchema, WriteRequestSchema, WriteResultSchema, SubscribeRequestSchema, ChangeEventSchema, RecordsRequestSchema, RecordsResponseSchema, STATE_RECORDS_VERSION, ScopeSchema, scopePath, stateHash, actionReceiptId, commitmentId, derivedId, assertReadWithinGrants, assertWriteWellFormed, assertDerivedState, } from "../core/stateContract.js";
+import { STATE_CAPABILITIES, STATE_CONTRACT_VERSION, STATE_FACETS, STATE_READ_VERSION, STATE_SUBSCRIBE_VERSION, STATE_WRITE_VERSION, ReadRequestSchema, ReadResponseSchema, WriteRequestSchema, WriteResultSchema, SubscribeRequestSchema, ChangeEventSchema, RecordsRequestSchema, RecordsResponseSchema, STATE_RECORDS_VERSION, ScopeSchema, scopePath, stateHash, actionReceiptId, commitmentId, derivedId, externalKey, subjectOfRef, assertReadWithinGrants, assertWriteWellFormed, assertDerivedState, isHumanConfirmed, } from "../core/stateContract.js";
 /** A typed refusal. `code` is stable for bindings; `conflict` names the incumbent when one exists. */
 export class StateRefusal extends Error {
     code;
@@ -81,7 +81,9 @@ export function capabilities(store) {
 }
 // ---- homing --------------------------------------------------------------------------------
 const granted = (principal, scope) => principal.grants.some((g) => scopePath(g) === scopePath(scope));
-function homeFor(store, scope) {
+/** Where a scope's records and ledger live in this store (exported for the replay check, which
+ *  must read the SAME home the write verb wrote — never a second routing rule). */
+export function stateHomeFor(store, scope) {
     const own = partitionOf(store);
     if (scopePath(scope) === scopePath(own)) {
         // The store IS this partition: its capture home (public `.hunch/`, or the overlay in shared mode).
@@ -104,6 +106,62 @@ const recordScope = (record, repo) => {
 function refOf(facet, record, scope) {
     return { facet, id: record.id, record_hash: stateHash(record), scope };
 }
+/** Follow `merged_into` to the entity that stands for this one now (cycle-safe, bounded). */
+function survivorOf(byId, entity) {
+    let current = entity;
+    const seen = new Set([current.id]);
+    while (current.lifecycle === "retired" && current.merged_into) {
+        const next = byId.get(current.merged_into);
+        if (!next || seen.has(next.id))
+            break;
+        seen.add(next.id);
+        current = next;
+    }
+    return current;
+}
+/** The entities in the principal's grants that stand for an external key or an entity id — active
+ *  ones directly, retired-and-merged ones through the survivor they name. */
+function entityIndex(store, principal, repo) {
+    const byId = new Map();
+    for (const e of store.recs("entities"))
+        if (granted(principal, recordScope(e, repo)))
+            byId.set(e.id, e);
+    const survivor = (e) => survivorOf(byId, e);
+    const byKey = new Map();
+    const bySubject = new Map();
+    for (const e of byId.values()) {
+        const stands = e.lifecycle === "active" ? e : (e.lifecycle === "retired" && e.merged_into ? survivor(e) : null);
+        if (!stands || stands.lifecycle !== "active")
+            continue;
+        for (const ref of e.refs) {
+            if (!byKey.has(externalKey(ref)) || e.lifecycle === "active")
+                byKey.set(externalKey(ref), stands);
+            if (!bySubject.has(subjectOfRef(ref)) || e.lifecycle === "active")
+                bySubject.set(subjectOfRef(ref), stands);
+        }
+    }
+    return { byKey, bySubject, byId, survivor };
+}
+/** The names one subject is filed under: itself, the entity that stands for it (through merges),
+ *  every entity merged into that one, and every key any of them carries. Explicit refs only. */
+function subjectAliases(store, principal, repo, subject) {
+    const aliases = new Set([subject]);
+    const { bySubject, byId, survivor } = entityIndex(store, principal, repo);
+    const named = bySubject.get(subject) ?? byId.get(subject);
+    if (!named)
+        return aliases;
+    const stands = survivor(named);
+    if (stands.lifecycle !== "active")
+        return aliases;
+    for (const e of byId.values()) {
+        if (e.id !== stands.id && survivor(e).id !== stands.id)
+            continue;
+        aliases.add(e.id);
+        for (const ref of e.refs)
+            aliases.add(subjectOfRef(ref));
+    }
+    return aliases;
+}
 /** read — the system-of-record answer for a subject, under the delivery envelope's receipt.
  *  Grants are the first predicate on every candidate; a matching record in a scope the
  *  principal lacks is NAMED in denied_scopes and never described. */
@@ -133,6 +191,11 @@ export function readState(store, input) {
             denied.set(scopePath(s), s);
     if (request.subject !== undefined) {
         const subject = request.subject;
+        // Subject identity by external reference: a read for an external record's key (`event:26904`,
+        // `customer:Site:7`) also finds what is filed under the entity that carries that ref, and a
+        // read for the entity id finds what was filed under its keys — one explicit hop, grants first.
+        const aliases = subjectAliases(store, request.principal, repo, subject);
+        const isSubject = (s) => s !== undefined && aliases.has(s);
         const current = [];
         const inForce = [];
         const done = [];
@@ -173,7 +236,7 @@ export function readState(store, input) {
             }
         if (facets.has("receipts"))
             for (const r of store.recs("receipts")) {
-                const targets = r.id === subject || r.invalidates.includes(subject) || `${r.target.object_type}:${r.target.object_key}` === subject;
+                const targets = r.id === subject || r.invalidates.some(isSubject) || isSubject(subjectOfRef(r.target));
                 if (!targets)
                     continue;
                 const scope = admit("receipts", r);
@@ -183,12 +246,12 @@ export function readState(store, input) {
                     done.push(keep("receipts", r, scope));
                     dependsOn.push(...(r.rests_on ?? []));
                 }
-                if (r.invalidates.includes(subject))
+                if (r.invalidates.some(isSubject))
                     invalidatedBy.add(r.id);
             }
         if (facets.has("commitments"))
             for (const c of store.recs("commitments")) {
-                if (c.subject !== subject && c.id !== subject)
+                if (!isSubject(c.subject) && c.id !== subject)
                     continue;
                 const scope = admit("commitments", c);
                 if (!scope)
@@ -202,7 +265,7 @@ export function readState(store, input) {
             }
         if (facets.has("derived"))
             for (const d of store.recs("derived")) {
-                if (d.subject !== subject && d.id !== subject)
+                if (!isSubject(d.subject) && d.id !== subject)
                     continue;
                 const scope = admit("derived", d);
                 if (!scope)
@@ -214,7 +277,7 @@ export function readState(store, input) {
             }
         if (facets.has("entities"))
             for (const e of store.recs("entities")) {
-                if (e.id !== subject)
+                if (!isSubject(e.id))
                     continue;
                 const scope = admit("entities", e);
                 if (!scope)
@@ -224,7 +287,7 @@ export function readState(store, input) {
             }
         if (facets.has("relationships"))
             for (const r of store.recs("relationships")) {
-                if (r.from !== subject && r.to !== subject)
+                if (!isSubject(r.from) && !isSubject(r.to))
                     continue;
                 const scope = admit("relationships", r);
                 if (!scope)
@@ -407,6 +470,54 @@ function assertClosedBy(store, principal, commitment) {
     }
     return commitment.closed_by;
 }
+/** one-entity-per-external-ref. An entity: no other active entity in the partition may carry one
+ *  of its external keys (the incumbent is named; merge/split are explicit, later). A commitment or
+ *  derived statement: its subject may not be the external key of a record an entity already
+ *  carries — the entity's id is the subject, and the refusal names it (the writer re-derives;
+ *  ids derive from the subject, so nothing is rewritten under it). A subject no entity claims
+ *  stays a free-form key: explicit refs only, no guessing. */
+function assertExternalIdentity(store, principal, scope, facet, record) {
+    const repo = partitionOf(store);
+    const inPartition = (e) => scopePath(recordScope(e, repo)) === scopePath(scope);
+    if (facet === "entities") {
+        const entity = record;
+        if (entity.merged_into !== undefined) {
+            const target = store.recs("entities").find((e) => e.id === entity.merged_into);
+            if (!target || !inPartition(target))
+                throw new StateRefusal("conflict", `merged_into ${entity.merged_into} is not an entity on record in ${scopePath(scope)}: a merge names a survivor that exists — write it first`, { incumbent_id: entity.merged_into, reason: "merge survivor absent" });
+            if (!granted(principal, recordScope(target, repo)))
+                throw new StateRefusal("outside-grants", `merged_into ${entity.merged_into} is outside the principal's grants`);
+            if (target.lifecycle !== "active")
+                throw new StateRefusal("conflict", `merged_into ${entity.merged_into} is ${target.lifecycle}${target.merged_into ? ` (merged into ${target.merged_into})` : ""}: the survivor of a merge is an active entity — merge into the one that stands now`, { incumbent_id: target.merged_into ?? target.id, reason: "merge survivor not active" });
+        }
+        if (entity.lifecycle !== "active")
+            return;
+        const keys = new Set(entity.refs.map(externalKey));
+        for (const other of store.recs("entities")) {
+            if (other.id === entity.id || other.lifecycle !== "active" || !inPartition(other))
+                continue;
+            const shared = other.refs.map(externalKey).find((k) => keys.has(k));
+            if (shared)
+                throw new StateRefusal("conflict", `${shared} is already carried by entity ${other.id} in ${scopePath(scope)}: one external record is one entity — write under ${other.id}, or retire it first (merge and split are explicit)`, { incumbent_id: other.id, reason: "one-entity-per-external-ref" });
+        }
+        return;
+    }
+    if (facet !== "commitments" && facet !== "derived")
+        return;
+    const subject = record.subject;
+    const { bySubject, byId, survivor } = entityIndex(store, principal, repo);
+    const byKey = bySubject.get(subject);
+    if (byKey && byKey.id !== subject && inPartition(byKey)) {
+        throw new StateRefusal("identity", `subject ${subject} is the external key of entity ${byKey.id} in ${scopePath(scope)}: the entity's id is the subject — re-derive with subject ${byKey.id}`, { incumbent_id: byKey.id, reason: "subject is an entity's external key" });
+    }
+    const named = byId.get(subject);
+    if (named && named.lifecycle === "retired" && named.merged_into && inPartition(named)) {
+        const stands = survivor(named);
+        if (stands.id !== named.id && stands.lifecycle === "active") {
+            throw new StateRefusal("identity", `subject ${subject} was merged into ${stands.id}: new state goes under the survivor — re-derive with subject ${stands.id}`, { incumbent_id: stands.id, reason: "subject was merged" });
+        }
+    }
+}
 /** Top-level fields whose canonical hash differs between two records, sorted. */
 function differingFields(a, b) {
     const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
@@ -488,13 +599,14 @@ export function writeState(store, input, opts = {}) {
     catch (e) {
         throw new StateRefusal(/grants/.test(e.message) ? "outside-grants" : "malformed", e.message);
     }
-    const { home, hunchDir, isPrivate } = homeFor(store, request.scope);
+    const { home, hunchDir, isPrivate } = stateHomeFor(store, request.scope);
     const now = (opts.now ?? (() => new Date()))().toISOString();
     const facet = request.facet;
     if (!ENTITY_KINDS.includes(facet))
         throw new StateRefusal("unsupported", `facet ${facet} is not a store kind`);
     const record = normalizeRecord(facet, request.scope, request.record, request.principal);
     const id = record.id;
+    assertExternalIdentity(store, request.principal, request.scope, facet, record);
     /** The normalized PAYLOAD hash: what idempotency recognizes on a re-send. */
     const hash = stateHash(record);
     const ledger = readLedger(hunchDir, request.scope);
@@ -531,8 +643,42 @@ export function writeState(store, input, opts = {}) {
         if (!ok)
             throw new StateRefusal("conflict", `expected_version does not match the incumbent ${id}`, { incumbent_id: id, reason: "expected_version mismatch" });
     }
-    // one-live-decision-per-topic — refuse with the incumbent named; supersession is explicit.
+    // human-correction-outranks-agent-writes: what a human confirmed, an agent does not rewrite.
+    // Allowed for an agent: a replay (the same facts, the tier downgrade aside), a derived statement
+    // written back stale with the external cause that moved (the writer's currentness duty), a
+    // commitment closed by a receipt on record (a fact that happened) — both keep the human's
+    // provenance on the record. Everything else on a human-confirmed incumbent — in place or by
+    // supersession — is refused with the incumbent named.
     let supersedes = request.supersedes ?? null;
+    if (request.principal.kind !== "human") {
+        const guard = (incumbent, how) => {
+            if (!incumbent || !isHumanConfirmed(incumbent))
+                return null;
+            const incumbentId = String(incumbent.id);
+            const changed = how === "overwrite" ? differingFields(incumbent, record).filter((f) => f !== "provenance") : ["a new record"];
+            if (how === "overwrite") {
+                if (changed.length === 0)
+                    return "replay";
+                const staleWithCause = facet === "derived" && incumbent.state === "current" && record.state === "stale" && request.cause?.kind === "external"
+                    && changed.every((f) => f === "state" || f === "valid_to");
+                const closedByReceipt = facet === "commitments" && !!record.closed_by && record.status === "done"
+                    && changed.every((f) => f === "status" || f === "closed_by" || f === "valid_to");
+                if (staleWithCause || closedByReceipt)
+                    return "keep-provenance";
+            }
+            throw new StateRefusal("conflict", `${incumbentId} was confirmed by a human; ${request.principal.kind === "agent" ? "an agent" : "a service"} principal may not ${how} it (differs in: ${changed.join(", ")}). A human writes the change, or the agent leaves the record as the human left it.`, { incumbent_id: incumbentId, reason: "human-confirmed incumbent" });
+        };
+        const verdict = guard(existing, "overwrite");
+        if (verdict === "replay") {
+            appendChanges(hunchDir, request.scope, [], { key: request.idempotency_key, entry: { record_id: id, record_hash: stateHash(existing), payload_hash: hash, facet } }, now);
+            return result("replayed");
+        }
+        if (verdict === "keep-provenance")
+            record.provenance = existing.provenance;
+        if (supersedes && supersedes !== id)
+            guard(store.getRec(facet, supersedes), "supersede");
+    }
+    // one-live-decision-per-topic — refuse with the incumbent named; supersession is explicit.
     if (facet === "decisions") {
         const d = record;
         if (d.topic && d.status === "accepted") {
@@ -580,6 +726,8 @@ export function writeState(store, input, opts = {}) {
     // ledger says so, and names the external pointer that moved when the writer gives one.
     const invalidated = facet === "derived" && !!existing && existing.state === "current" && record.state === "stale";
     const invalidates = facet === "receipts" ? record.invalidates : [];
+    // An entity leaving service is a `retired` change (a merge names the survivor in the record).
+    const retired = facet === "entities" && record.lifecycle === "retired" && (!existing || existing.lifecycle !== "retired");
     const subject = subjectOf(facet, record);
     if (supersedes) {
         const closed = closeWindow(store, facet, supersedes, id, now, isPrivate);
@@ -588,7 +736,7 @@ export function writeState(store, input, opts = {}) {
             changes.push({ facet, record_id: supersedes, record_hash: stateHash(old), change: "superseded", subject: subjectOf(facet, old), invalidates: [], cause });
         }
     }
-    changes.push({ facet, record_id: id, record_hash: onFileHash, change: invalidated ? "invalidated" : existing ? "updated" : "created", subject, invalidates: invalidated && subject ? [subject] : invalidates, cause });
+    changes.push({ facet, record_id: id, record_hash: onFileHash, change: invalidated ? "invalidated" : retired ? "retired" : existing ? "updated" : "created", subject, invalidates: invalidated && subject ? [subject] : invalidates, cause });
     appendChanges(hunchDir, request.scope, changes, { key: request.idempotency_key, entry: { record_id: id, record_hash: onFileHash, payload_hash: hash, facet } }, now);
     store.reindex();
     return result(supersedes ? "superseded" : existing ? "updated" : "created");
@@ -600,7 +748,7 @@ export function subscribeState(store, input) {
     const request = SubscribeRequestSchema.parse(input);
     if (!granted(request.principal, request.scope))
         throw new StateRefusal("outside-grants", `scope ${scopePath(request.scope)} is outside the principal's grants`);
-    const { hunchDir } = homeFor(store, request.scope);
+    const { hunchDir } = stateHomeFor(store, request.scope);
     const ledger = readLedger(hunchDir, request.scope);
     const facets = request.facets ? new Set(request.facets) : null;
     const subjects = request.subjects ? new Set(request.subjects) : null;

package/dist/synthesis/cliAdapter.js

@@ -0,0 +1,168 @@
+/** Extensible local CLI transport. Executables/arguments come only from explicit user config. */
+import spawn from "cross-spawn";
+import { execFile } from "node:child_process";
+import { mkdtempSync, readFileSync, realpathSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, relative } from "node:path";
+import { z } from "zod";
+import { assertInitiatorProvider, initiatorChildEnv } from "./initiator.js";
+const adapterSchema = z.object({
+    name: z.string().regex(/^[a-z][a-z0-9-]{0,59}$/),
+    command: z.string().min(1).max(1000).refine(s => !/[\r\n\0]/.test(s)),
+    args: z.array(z.string().max(2000).refine(s => !/[\r\n\0]/.test(s))).max(40),
+    protocol: z.enum(["stdin", "acp"]),
+    probe_args: z.array(z.string().max(200).refine(s => !/[\r\n\0]/.test(s))).max(10).default(["--version"]),
+    timeout_ms: z.number().int().min(1000).max(600000).default(120000),
+}).strict();
+export function readAgentCliConfig(file) {
+    if (statSync(file).size > 64 * 1024)
+        throw new Error("CLI adapter config exceeds 64 KiB");
+    const adapters = z.array(adapterSchema).max(20).parse(JSON.parse(readFileSync(file, "utf8")));
+    if (new Set(adapters.map(a => a.name)).size !== adapters.length)
+        throw new Error("duplicate CLI adapter names");
+    return adapters;
+}
+/** ACP (Kimi and other agents) or plain stdin → JSON stdout for any user-configured CLI. */
+export async function runAgentCli(adapterInput, prompt) {
+    const adapter = adapterSchema.parse(adapterInput);
+    assertInitiatorProvider(adapter.name);
+    const parent = realpathSync(tmpdir());
+    const cwd = mkdtempSync(join(parent, "hunch-agent-provider-"));
+    const child = spawn(adapter.command, adapter.args, { cwd, env: initiatorChildEnv(), windowsHide: true, stdio: "pipe" });
+    const stop = () => {
+        if (process.platform === "win32" && child.pid) {
+            execFile("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true }, () => { });
+        }
+        child.kill();
+    };
+    try {
+        return await new Promise((resolve, reject) => {
+            let done = false;
+            let buffer = "";
+            let output = "";
+            let bytes = 0;
+            let sequence = 0;
+            let sessionId;
+            const waiting = new Map();
+            const finish = (error) => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                if (error)
+                    reject(error);
+                else
+                    resolve(output.trim());
+            };
+            const timer = setTimeout(() => { finish(new Error("CLI provider timed out")); stop(); }, adapter.timeout_ms);
+            const send = (message) => child.stdin.write(JSON.stringify(message) + "\n");
+            const request = (method, params, callback) => {
+                const id = ++sequence;
+                waiting.set(id, callback);
+                send({ jsonrpc: "2.0", id, method, params });
+            };
+            const receive = (line) => {
+                const message = JSON.parse(line);
+                if (message.method && message.id !== undefined) {
+                    // No permission approvals, filesystem reads/writes or shell services are granted.
+                    if (message.method === "session/request_permission") {
+                        send({ jsonrpc: "2.0", id: message.id, result: { outcome: { outcome: "cancelled" } } });
+                    }
+                    else
+                        send({ jsonrpc: "2.0", id: message.id, error: { code: -32601, message: "Unavailable in review-only client" } });
+                    return;
+                }
+                if (message.method === "session/update") {
+                    const params = message.params;
+                    if (params?.sessionId === sessionId && params.update?.sessionUpdate === "agent_message_chunk"
+                        && params.update.content?.type === "text" && typeof params.update.content.text === "string")
+                        output += params.update.content.text;
+                }
+                else if (typeof message.id === "number" && waiting.has(message.id)) {
+                    const callback = waiting.get(message.id);
+                    waiting.delete(message.id);
+                    if (message.error || !message.result || typeof message.result !== "object")
+                        throw new Error("ACP request failed");
+                    callback(message.result);
+                }
+            };
+            child.on("error", () => finish(new Error("CLI provider could not start")));
+            child.stdin.on("error", () => finish(new Error("CLI provider input closed")));
+            child.stderr.on("data", () => { }); // drain without collecting credentials or raw prompts
+            child.stdout.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                if (done)
+                    return;
+                bytes += Buffer.byteLength(chunk);
+                if (bytes > 2 * 1024 * 1024) {
+                    finish(new Error("CLI provider exceeded output budget"));
+                    stop();
+                    return;
+                }
+                if (adapter.protocol === "stdin") {
+                    output += chunk;
+                    return;
+                }
+                buffer += chunk;
+                try {
+                    let newline;
+                    while ((newline = buffer.indexOf("\n")) >= 0 && !done) {
+                        const line = buffer.slice(0, newline).trim();
+                        buffer = buffer.slice(newline + 1);
+                        if (line)
+                            receive(line);
+                    }
+                }
+                catch {
+                    finish(new Error("Invalid ACP response"));
+                }
+            });
+            child.on("close", code => {
+                if (adapter.protocol === "stdin" && code === 0)
+                    finish();
+                else
+                    finish(new Error("CLI provider exited before completing review"));
+            });
+            if (adapter.protocol === "stdin")
+                child.stdin.end(prompt);
+            else
+                request("initialize", { protocolVersion: 1, clientInfo: { name: "hunch-review-memory", version: "1" },
+                    clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: true } }, initialized => {
+                    if (initialized.protocolVersion !== 1)
+                        throw new Error("Unsupported ACP protocol");
+                    request("session/new", { cwd, mcpServers: [] }, session => {
+                        if (typeof session.sessionId !== "string" || !session.sessionId)
+                            throw new Error("Missing ACP session");
+                        sessionId = session.sessionId;
+                        request("session/prompt", { sessionId, prompt: [{ type: "text", text: prompt }] }, result => {
+                            if (result.stopReason !== "end_turn")
+                                throw new Error("ACP turn did not complete");
+                            finish();
+                        });
+                    });
+                });
+        });
+    }
+    finally {
+        stop();
+        // Only remove the directory created for this invocation, after checking its resolved boundary.
+        const rel = relative(parent, realpathSync(cwd));
+        if (!isAbsolute(rel) && rel.startsWith("hunch-agent-provider-") && !rel.includes("/") && !rel.includes("\\")) {
+            try {
+                rmSync(cwd, { recursive: true, force: true });
+            }
+            catch { /* transient Windows handles; never affect review result */ }
+        }
+    }
+}
+export function discoverAgentClis(configured = [], initiator) {
+    const kimi = adapterSchema.parse({ name: "kimi-cli", command: "kimi", args: ["acp"], protocol: "acp" });
+    const adapters = [...configured, ...(configured.some(a => a.name === kimi.name) ? [] : [kimi])];
+    return adapters.filter(adapter => !initiator || adapter.name === initiator).filter(adapter => {
+        const result = spawn.sync(adapter.command, adapter.probe_args, {
+            cwd: tmpdir(), encoding: "utf8", windowsHide: true, timeout: 5000, maxBuffer: 64 * 1024,
+        });
+        return !result.error && result.status === 0;
+    }).map(adapter => ({ name: adapter.name, draftProse: prompt => runAgentCli(adapter, prompt) }));
+}
+//# sourceMappingURL=cliAdapter.js.map

package/dist/synthesis/initiator.js

@@ -0,0 +1,58 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const context = new AsyncLocalStorage();
+const aliases = { claude: "claude-cli", codex: "codex-cli", cursor: "cursor-agent", kimi: "kimi-cli", ollama: "openai-compat" };
+export function normalizeInitiator(name) {
+    const normalized = aliases[name] ?? name;
+    if (!/^[a-z][a-z0-9-]{0,59}$/.test(normalized) || ["auto", "available", "deterministic"].includes(normalized)) {
+        throw new Error("Initiator must identify one concrete agent provider.");
+    }
+    return normalized;
+}
+export function detectInitiator(env = process.env) {
+    if (env.HUNCH_INITIATOR === "unknown")
+        return { provider: null, source: "unknown" };
+    if (env.HUNCH_INITIATOR)
+        return { provider: normalizeInitiator(env.HUNCH_INITIATOR), source: "explicit" };
+    const names = new Set();
+    if (env.CODEX_THREAD_ID || env.CODEX_SESSION_ID)
+        names.add("codex-cli");
+    if (env.CLAUDECODE === "1")
+        names.add("claude-cli");
+    return { provider: names.size === 1 ? [...names][0] : null,
+        source: names.size === 1 ? "environment" : names.size > 1 ? "ambiguous" : "unknown" };
+}
+export function currentInitiator(env = process.env) {
+    return context.getStore() ?? detectInitiator(env);
+}
+export function withInitiator(initiator, work) {
+    return context.run(Object.freeze({ ...initiator }), work);
+}
+/** Bind the MCP client, not the process that happened to start the server. Unknown clients stay unknown. */
+export function initiatorFromClient(name) {
+    const lower = name?.toLowerCase() ?? "";
+    const providers = [
+        [/\bclaude(?:[ _-]code)?\b/, "claude-cli"], [/\bcodex\b/, "codex-cli"],
+        [/\bcursor\b/, "cursor-agent"], [/\bkimi\b/, "kimi-cli"],
+    ];
+    const matched = providers.filter(([pattern]) => pattern.test(lower));
+    return { provider: matched.length === 1 ? matched[0][1] : null,
+        source: matched.length > 1 ? "ambiguous" : "client" };
+}
+/** Freeze the operation's origin before spawning Git hooks or other deferred children. */
+export function initiatorChildEnv(env = process.env) {
+    const origin = currentInitiator(env);
+    return { ...env, HUNCH_INITIATOR: origin.provider ?? "unknown" };
+}
+export function assertInitiatorProvider(provider) {
+    const origin = currentInitiator();
+    if (origin.provider && origin.provider !== provider)
+        throw new Error(`Initiator ${origin.provider} cannot launch ${provider}; refusing an account switch.`);
+    if (origin.source === "ambiguous")
+        throw new Error("Ambiguous initiating agent; refusing to launch another provider.");
+    if (origin.source === "client" && !origin.provider)
+        throw new Error("Unknown initiating MCP client; refusing to launch another provider.");
+    if (!origin.provider && (context.getStore() || process.env.HUNCH_INITIATOR === "unknown")) {
+        throw new Error("Unknown initiating event; refusing to launch another provider.");
+    }
+}
+//# sourceMappingURL=initiator.js.map