pi-daddy 0.32.1 → 0.35.0

package/CHANGELOG.md

@@ -12,6 +12,89 @@ the record of how the package got here and are worth keeping; they are not worth
 > the record of how the package arrived at what it does, and because the reasoning behind each one is
 > usually the clearest statement of why the current behaviour is what it is.
 
+## 0.35.0 — the first two decision points, and only the environment can enable an advisor
+
+**An advisor now fills two blanks.** When a `delegate` call names no `thinking` level, an enabled advisor is asked
+to choose one from the levels the CHILD's model reports it supports. An explicit level is never overruled, and with
+no advisor, no answer or a timeout the blank stays blank and the child is spawned exactly as before. The task text
+is sent to the advisor so it has something to judge; it is still never recorded.
+
+**A `pruned` context handoff can now ask which turns to carry.** The mechanical rule runs first and decides what is
+eligible; the advisor is then shown at most twelve of those turns, truncated, and may only NARROW the set — an id
+it invents or one the rule dropped is ignored, and an incomplete answer is discarded whole. The selection is asked
+only after a plan says the handoff survived the ceiling, the grant and the gate, so a delegation the grant refuses
+never ships session turns. With no advisor or no usable answer, the mechanical selection stands unchanged.
+
+**This sends more than the effort point does.** A `pruned` handoff sends the operator's own session turns, not just
+the task, to a third party. That is the sharpest egress in the package and it is why an advisor is off by default,
+enabled only from the environment, and reported by `/grants`.
+
+**Security fix over 0.34.0.**
+
+0.34.0 read the advisor's enable switch from `.pi/pi-daddy/settings.json`. That file is writable by any child
+holding `tool:write`, and this package keeps the grant outside the workspace for exactly that reason: a ceiling a
+governed child can rewrite is not a ceiling. The same argument applies here one step sideways — a child could have
+flipped the switch and made the operator's next session send its own description to a third party.
+
+**What to do.** Enabling an advisor is now `PI_DADDY_ADVISOR=jev` alongside `PI_DADDY_ADVISOR_KEY`, with
+`PI_DADDY_ADVISOR_MODEL` to override the model; all three are stripped from a child spawned as a subprocess. A
+Herdr pane inherits the daemon's environment, so a daemon started from a shell exporting them still hands them to
+pane children — stated rather than implied, and not yet closed.
+
+A project's `advisor` block in `settings.json` may turn an advisor off for that project and shorten its timeout. It
+can no longer turn one on, choose its model, or lengthen its bound: a model is a destination and a longer bound is
+not a narrowing, and that file is writable by any child holding `tool:write`. Anything that is not exactly `true`
+on `enabled` disables. So a settings file that relied on `enabled: true` will find the advisor off until the
+environment variable is set, and one that set `model` will be refused with a message naming the variable to use.
+
+## 0.34.0 — an advisors layer, off by default (ADR-0077)
+
+`src/advisors/` holds a `Decider` that answers typed questions — `noul` (a boolean), `choice` (one of the options
+the caller already had) and `score` (a level from the caller's own list) — each with a probability. It may select,
+rank, annotate or propose, and it can never widen a grant, satisfy a gate or replace a human's answer. That is
+enforced rather than promised: no type in the layer names a capability or a refusal code, and no kernel or
+governance module imports it, both checked by tests.
+
+Off by default. An advisor runs only when `.pi/pi-daddy/settings.json` has an `advisor` block saying so and
+`PI_DADDY_ADVISOR_KEY` is set; malformed configuration disables it and names the field rather than failing either
+silently or open. Every use writes an `advice` record to the ledger, including the uses that produced nothing, and
+that record never contains the state the caller composed. Degradation is always "no advice": disabled, no key, a
+two-second timeout, a transport error or an unrecognised response all return the same nothing, so a caller written
+against the null decider behaves identically with an advisor present.
+
+The first adapter is TypeSafe's Jev through OpenRouter's Decisions endpoint (`typesafe/jev-1.13`). The request shape
+is the documented one. The response shape is **not confirmed against a live call** — OpenRouter describes the
+`answers` object without showing it — so the parser accepts what the documentation describes and treats anything
+else, including a choice that was never offered, as no advice. No decision point uses an advisor yet.
+
+There is no dashboard toggle: the dashboard is a read-only renderer that never affects enforcement, so enabling an
+advisor is an operator edit to the reviewable settings file.
+
+## 0.33.0 — a child can be given context, and the giving attenuates (ADR-0078)
+
+`delegate`, `delegate_all` and each fan-out child accept a `context` parameter naming how much of the parent's own
+session crosses: `none` (the default, and what every child got before), `files`, `pruned`, `summary` or `fork`. Each
+mode is a `context:<mode>` capability in a new namespace, so it is intersected with the parent's grant and the
+definition's `allowed-tools` ceiling exactly like a tool, appears in `/grants` and in the ledger's effective set, and
+cannot be widened by a child. The modes are ordered and each subsumes the weaker ones.
+
+`context:fork` is **gated by default** beside `tool:bash`: it is the one mode that can carry content an untrusted
+repository put in front of the parent into a fresh child. What crosses arrives in a `<<<PARENT-CONTEXT …>>>` fence
+marked as data, distinct from the chain handoff's fence, capped at 32 KiB with anything dropped said inside the
+fence. Paths named for `files` are confined to the session's working directory. The capability-decision record gains
+`handoff`, naming the mode the child received, how many sections and bytes crossed, and for `pruned` which rule ran
+and how many turns it kept.
+
+Nothing changes for a caller that passes no `context`: the default is `none`, which adds no capability and crosses
+nothing. `pruned`'s selection rule is deterministic but its recall is unmeasured, so it is not a default.
+
+A `delegate_chain` step takes the same parameter. A chain is planned as one unit, so a step's handoff is capped by
+that step's own definition and any gate it raises is answered before the first step runs.
+
+**Breaking for consumers of the package API:** `splitSystemPrompt` now returns `systemPrompts: string[]` instead of
+`systemPrompt?: string`, because a child can carry more than one appended system prompt and only the first was being
+staged for the Herdr executor.
+
 ## 0.32.1 — a doubled namespace in `allowed-tools` is explained, not just reported
 
 An `allowed-tools` entry written with a capitalised namespace, such as `Tool:Read`, misses the lower-case prefix test,

package/contracts/ledger-record/v1/governance-event.schema.json

@@ -185,7 +185,8 @@
         "WORKSPACE_NOT_AUTHORIZED",
         "WORKSPACE_WRITE_CONFLICT",
         "WORKSPACE_LEASE_STALE",
-        "LEDGER_DAMAGED"
+        "LEDGER_DAMAGED",
+        "CONTEXT_REQUEST_INVALID"
       ]
     },
     "refusal": {
@@ -401,6 +402,50 @@
         "definitionDigest": {
           "$ref": "#/$defs/definitionDigest"
         },
+        "handoff": {
+          "type": "object",
+          "description": "the context handoff this child received (ADR-0078); absent means nothing crossed",
+          "additionalProperties": false,
+          "required": [
+            "mode",
+            "sections",
+            "bytes",
+            "truncatedBytes"
+          ],
+          "properties": {
+            "mode": {
+              "enum": [
+                "files",
+                "pruned",
+                "summary",
+                "fork"
+              ]
+            },
+            "sections": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "bytes": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "truncatedBytes": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "keptTurns": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "droppedTurns": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "rule": {
+              "type": "string"
+            }
+          }
+        },
         "executor": {
           "type": "string",
           "enum": [

package/dist/advisors/advisor.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The wrapper that makes "every use is recorded" structural rather than a rule (ADR-0077).
+ *
+ * A caller cannot reach a `Decider` directly through this layer's public surface: it asks an `Advisor`, and asking
+ * always produces an `advice` record — including when the answer was "no advice", which is the case a reviewer most
+ * needs to see, because an advisor that silently stops answering would otherwise look exactly like one nobody used.
+ *
+ * **What is recorded, and what is not.** The record names the purpose, the decider, the question keys, the answers
+ * and how long it took. It does NOT contain the state. A caller composes that state from its own context, which can
+ * include task text, file contents and a repository's private material; the ledger has never stored a task
+ * (ADR-0021) and an advisor must not become the way it starts. The question keys are the caller's own constants,
+ * so they name the decision without describing the situation.
+ */
+import type { Advice, AdviceRequest, Decider } from "./decider.ts";
+/** Two seconds. An advisor is on the path of a decision a human is waiting for; it is not worth more than that. */
+export declare const DEFAULT_ADVICE_TIMEOUT_MS = 2000;
+export interface AdviceRecord {
+    /** Which decision this advice was for, from the caller's own closed list. */
+    purpose: string;
+    decider: string;
+    /** Question keys only — never the state, and never a question's free text. */
+    questions: string[];
+    answered: boolean;
+    durationMs: number;
+    /** Present only when advice came back. */
+    answers?: Readonly<Record<string, {
+        value: string | number | boolean;
+        confidence?: number;
+    }>>;
+    model?: string;
+    /**
+     * Why there is no advice. `declined` means the advisor answered with nothing; `error` means it could not be
+     * reached or its response was unrecognised; `cancelled` means the CALLER went away, which is not the advisor's
+     * failure and must not read as one.
+     */
+    outcome: "answered" | "disabled" | "timeout" | "error" | "declined" | "cancelled";
+}
+export interface Advisor {
+    ask(purpose: string, request: AdviceRequest, signal?: AbortSignal): Promise<Advice | null>;
+}
+export declare function createAdvisor(input: {
+    decider: Decider;
+    /** Where the record goes. Injected so this layer does no I/O and governance does not import it. */
+    record: (entry: AdviceRecord) => void | Promise<void>;
+    timeoutMs?: number;
+    /** Absent or false means the null decider is used whatever `decider` says. */
+    enabled?: boolean;
+}): Advisor;
+//# sourceMappingURL=advisor.d.ts.map

package/dist/advisors/advisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advisor.d.ts","sourceRoot":"","sources":["../../src/advisors/advisor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEnE,mHAAmH;AACnH,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IAC9F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,OAAO,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,UAAU,GAAG,WAAW,CAAC;CACnF;AAED,MAAM,WAAW,OAAO;IACtB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC5F;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,mGAAmG;IACnG,MAAM,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CA+DV"}

package/dist/advisors/advisor.js

@@ -0,0 +1,76 @@
+/** Two seconds. An advisor is on the path of a decision a human is waiting for; it is not worth more than that. */
+export const DEFAULT_ADVICE_TIMEOUT_MS = 2000;
+export function createAdvisor(input) {
+    const timeoutMs = input.timeoutMs ?? DEFAULT_ADVICE_TIMEOUT_MS;
+    return {
+        async ask(purpose, request, signal) {
+            const started = Date.now();
+            const base = { purpose, decider: input.decider.name, questions: Object.keys(request.questions) };
+            const write = async (entry) => {
+                try {
+                    await input.record(entry);
+                }
+                catch {
+                    // Recording is an observation of a decision that has already been taken. Failing to write it must not
+                    // change what the caller does, for `execute-child`'s reason: an audit failure that discards the work is
+                    // worse than one that is merely missing.
+                }
+            };
+            if (input.enabled !== true) {
+                await write({ ...base, decider: "none", answered: false, durationMs: 0, outcome: "disabled" });
+                return null;
+            }
+            const timer = new AbortController();
+            const cancel = setTimeout(() => timer.abort(), timeoutMs);
+            const linked = signal ? AbortSignal.any([signal, timer.signal]) : timer.signal;
+            try {
+                // RACED, not merely signalled. A decider that ignores its signal would otherwise run as long as it liked
+                // and then be recorded as a timeout — measured at fifty times the configured bound. The `Decider` contract
+                // cannot make an implementation honour an abort, so the bound is enforced on this side of it.
+                const advice = await Promise.race([
+                    input.decider.decide(request, linked),
+                    new Promise((settle) => linked.addEventListener("abort", () => settle(null), { once: true })),
+                ]);
+                const durationMs = Date.now() - started;
+                if (!advice) {
+                    await write({ ...base, answered: false, durationMs, outcome: outcomeFor(timer.signal, signal, "declined") });
+                    return null;
+                }
+                await write({
+                    ...base,
+                    answered: true,
+                    durationMs,
+                    outcome: "answered",
+                    answers: Object.fromEntries(Object.entries(advice.answers).map(([key, answer]) => [
+                        key,
+                        { value: answer.value, ...(answer.confidence === undefined ? {} : { confidence: answer.confidence }) },
+                    ])),
+                    ...(advice.model ? { model: advice.model } : {}),
+                });
+                return advice;
+            }
+            catch {
+                // Including an abort. A caller asked for advice and is getting none; it proceeds exactly as it would have.
+                await write({
+                    ...base,
+                    answered: false,
+                    durationMs: Date.now() - started,
+                    outcome: outcomeFor(timer.signal, signal, "error"),
+                });
+                return null;
+            }
+            finally {
+                clearTimeout(cancel);
+            }
+        },
+    };
+}
+/** The bound fired, the caller went away, or neither — three different facts a reviewer needs to tell apart. */
+function outcomeFor(timer, caller, otherwise) {
+    if (timer.aborted && !caller?.aborted)
+        return "timeout";
+    if (caller?.aborted)
+        return "cancelled";
+    return otherwise;
+}
+//# sourceMappingURL=advisor.js.map

package/dist/advisors/advisor.js.map

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

package/dist/advisors/decider.d.ts

@@ -0,0 +1,79 @@
+/**
+ * An advisor is a thing that answers a typed question. It is never a thing that decides (ADR-0077).
+ *
+ * The boundary is the whole design, and it is structural rather than remembered: **no type in this layer names a
+ * `Capability` or a refusal code**, and no function in `kernel/` or `governance/` accepts an advisor's result. An
+ * advisor may select among options the caller already had, rank them, annotate them, or propose one. It can never
+ * widen an `effective` set, satisfy a gate, or stand in for a human's answer — not because it is asked not to, but
+ * because nothing on those paths can receive what it returns. `test/advisors.test.ts` forces that.
+ *
+ * Non-generative on purpose. The first advisor is a classifier that returns a typed answer with a probability, not
+ * prose, which is what makes an advisor auditable: "it chose `b` at 0.91" is a fact a reviewer can disagree with,
+ * where a paragraph of reasoning is not.
+ *
+ * Degradation is "no advice", never a guess. Every path that cannot produce an answer — disabled, missing key,
+ * timeout, transport error, a response shape we do not recognise — returns `null`, and the caller does what it
+ * would have done without an advisor at all. That is why a caller must be written to work with `nullDecider`
+ * first, and why `nullDecider` is the default.
+ */
+/** A question, in the three shapes the first advisor understands. */
+export type Question = {
+    kind: "noul";
+    instructions: string;
+    whenTrue: string;
+    whenFalse: string;
+} | {
+    kind: "choice";
+    instructions: string;
+    options: Readonly<Record<string, string>>;
+} | {
+    kind: "score";
+    instructions: string;
+    levels: readonly string[];
+};
+/** One typed answer. `confidence` is absent when the transport did not report one; it is never invented. */
+export type Answer = {
+    kind: "noul";
+    value: boolean;
+    confidence?: number;
+} | {
+    kind: "choice";
+    value: string;
+    confidence?: number;
+} | {
+    kind: "score";
+    value: number;
+    level: string;
+    confidence?: number;
+};
+export interface AdviceRequest {
+    /**
+     * What the advisor is told about the situation, composed by the caller.
+     *
+     * **Sent, never recorded.** The task is never STORED (ADR-0021) and that still holds — `createAdvisor` writes the
+     * question keys and the answers and never this object. But an advisor cannot judge a task it cannot see, so a
+     * caller that needs one judged does send it, and the operator's consent for that is the advisor being off by
+     * default. An earlier draft of this paragraph said the raw task "must not be shipped to a third party either",
+     * which the first decision point then did; the rule that survived review is the narrower and true one.
+     */
+    state: Readonly<Record<string, unknown>>;
+    questions: Readonly<Record<string, Question>>;
+}
+export interface Advice {
+    answers: Readonly<Record<string, Answer>>;
+    /** What actually answered, as the transport reported it — a dated model id, not the one we asked for. */
+    model?: string;
+}
+export interface Decider {
+    /** Recorded in the ledger so a reviewer can tell which advisor a decision was taken beside. */
+    readonly name: string;
+    decide(request: AdviceRequest, signal?: AbortSignal): Promise<Advice | null>;
+}
+/**
+ * The default, and the one every caller must work correctly with.
+ *
+ * Not a placeholder: it is how advisors stay optional. A caller that behaves differently under `nullDecider` than
+ * under no advisor at all has made advice load-bearing, which is the one thing ADR-0077 forbids.
+ */
+export declare const nullDecider: Decider;
+//# sourceMappingURL=decider.d.ts.map

package/dist/advisors/decider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decider.d.ts","sourceRoot":"","sources":["../../src/advisors/decider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,qEAAqE;AACrE,MAAM,MAAM,QAAQ,GAChB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC3E;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,GACnF;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAEvE,4GAA4G;AAC5G,MAAM,MAAM,MAAM,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAEtD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzE,MAAM,WAAW,aAAa;IAC5B;;;;;;;;OAQG;IACH,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1C,yGAAyG;IACzG,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,OAAO;IACtB,+FAA+F;IAC/F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC9E;AAED;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,OAGzB,CAAC"}

package/dist/advisors/decider.js

@@ -0,0 +1,29 @@
+/**
+ * An advisor is a thing that answers a typed question. It is never a thing that decides (ADR-0077).
+ *
+ * The boundary is the whole design, and it is structural rather than remembered: **no type in this layer names a
+ * `Capability` or a refusal code**, and no function in `kernel/` or `governance/` accepts an advisor's result. An
+ * advisor may select among options the caller already had, rank them, annotate them, or propose one. It can never
+ * widen an `effective` set, satisfy a gate, or stand in for a human's answer — not because it is asked not to, but
+ * because nothing on those paths can receive what it returns. `test/advisors.test.ts` forces that.
+ *
+ * Non-generative on purpose. The first advisor is a classifier that returns a typed answer with a probability, not
+ * prose, which is what makes an advisor auditable: "it chose `b` at 0.91" is a fact a reviewer can disagree with,
+ * where a paragraph of reasoning is not.
+ *
+ * Degradation is "no advice", never a guess. Every path that cannot produce an answer — disabled, missing key,
+ * timeout, transport error, a response shape we do not recognise — returns `null`, and the caller does what it
+ * would have done without an advisor at all. That is why a caller must be written to work with `nullDecider`
+ * first, and why `nullDecider` is the default.
+ */
+/**
+ * The default, and the one every caller must work correctly with.
+ *
+ * Not a placeholder: it is how advisors stay optional. A caller that behaves differently under `nullDecider` than
+ * under no advisor at all has made advice load-bearing, which is the one thing ADR-0077 forbids.
+ */
+export const nullDecider = {
+    name: "none",
+    decide: async () => null,
+};
+//# sourceMappingURL=decider.js.map

package/dist/advisors/decider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decider.js","sourceRoot":"","sources":["../../src/advisors/decider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAyCH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAY;IAClC,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,KAAK,IAAI,EAAE,CAAC,IAAI;CACzB,CAAC"}

package/dist/advisors/jev.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Jev, through OpenRouter's Decisions endpoint — the first advisor adapter (ADR-0077).
+ *
+ * **What is verified and what is not.** The REQUEST shape below is taken from OpenRouter's own SDK reference for
+ * `POST /api/alpha/decisions`: `{model, state, questions}`, where each question is `noul` with `criteria.true` and
+ * `criteria.false`, `choice` with a `criteria` map of option to description, or `score` with a `criteria` array of
+ * level descriptions. That much is documented. The RESPONSE is described there only as an `answers` object beside
+ * `id`, `model`, `provider` and `usage`, with probabilities and confidence mentioned but never shown, and the one
+ * public guide to this endpoint says plainly that it has not run paid calls either. **So no shape below has been
+ * confirmed against a live response.** The parser therefore accepts what the documentation describes, tolerates the
+ * obvious variants, and returns `null` for anything else rather than guessing — which is the same thing it does when
+ * the endpoint is down. A live check is the `PI_DADDY_IT_JEV=1` tier, and until somebody runs it this adapter's
+ * response handling is a reading of documentation, not a measurement.
+ *
+ * Nothing here can widen anything: it returns `Advice`, and no kernel or governance function accepts one.
+ */
+import type { Advice, AdviceRequest, Answer, Decider, Question } from "./decider.ts";
+export declare const JEV_ENDPOINT = "https://openrouter.ai/api/alpha/decisions";
+export declare const JEV_MODEL = "typesafe/jev-1.13";
+/** The wire form of one question, exactly as OpenRouter's reference documents it. */
+export declare function wireQuestion(question: Question): Record<string, unknown>;
+export declare function wireRequest(request: AdviceRequest, model: string): Record<string, unknown>;
+/**
+ * Read one answer out of a response, or nothing.
+ *
+ * Deliberately generous about WHERE the value and the probability sit, because the documentation names the fields
+ * without showing them, and strict about WHAT they are: a `choice` answer must be one of the options that were
+ * asked about, and a `score` must be an index into the levels. An answer outside the question's own vocabulary is
+ * not a low-confidence answer, it is a response we did not understand, and the honest reading of that is no advice.
+ */
+export declare function parseAnswer(question: Question, raw: unknown): Answer | undefined;
+export declare function parseAdvice(request: AdviceRequest, body: unknown): Advice | null;
+export interface JevConfig {
+    apiKey: string;
+    model?: string;
+    endpoint?: string;
+    /** Injected so the adapter is testable without a network, and so nothing here reaches for a global. */
+    fetch?: typeof globalThis.fetch;
+}
+export declare function jevDecider(config: JevConfig): Decider;
+//# sourceMappingURL=jev.d.ts.map

package/dist/advisors/jev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jev.d.ts","sourceRoot":"","sources":["../../src/advisors/jev.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAErF,eAAO,MAAM,YAAY,8CAA8C,CAAC;AACxE,eAAO,MAAM,SAAS,sBAAsB,CAAC;AAE7C,qFAAqF;AACrF,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUxE;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAM1F;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CA8BhF;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAchF;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uGAAuG;IACvG,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAuBrD"}

package/dist/advisors/jev.js

@@ -0,0 +1,108 @@
+export const JEV_ENDPOINT = "https://openrouter.ai/api/alpha/decisions";
+export const JEV_MODEL = "typesafe/jev-1.13";
+/** The wire form of one question, exactly as OpenRouter's reference documents it. */
+export function wireQuestion(question) {
+    if (question.kind === "noul")
+        return {
+            type: "noul",
+            instructions: question.instructions,
+            criteria: { true: question.whenTrue, false: question.whenFalse },
+        };
+    if (question.kind === "choice")
+        return { type: "choice", instructions: question.instructions, criteria: { ...question.options } };
+    return { type: "score", instructions: question.instructions, criteria: [...question.levels] };
+}
+export function wireRequest(request, model) {
+    return {
+        model,
+        state: request.state,
+        questions: Object.fromEntries(Object.entries(request.questions).map(([key, q]) => [key, wireQuestion(q)])),
+    };
+}
+/**
+ * Read one answer out of a response, or nothing.
+ *
+ * Deliberately generous about WHERE the value and the probability sit, because the documentation names the fields
+ * without showing them, and strict about WHAT they are: a `choice` answer must be one of the options that were
+ * asked about, and a `score` must be an index into the levels. An answer outside the question's own vocabulary is
+ * not a low-confidence answer, it is a response we did not understand, and the honest reading of that is no advice.
+ */
+export function parseAnswer(question, raw) {
+    if (raw === null || raw === undefined)
+        return undefined;
+    const object = typeof raw === "object" && !Array.isArray(raw) ? raw : undefined;
+    const value = object ? (object.value ?? object.answer ?? object.choice ?? object.result) : raw;
+    const confidenceRaw = object ? (object.confidence ?? object.probability ?? object.p) : undefined;
+    const confidence = typeof confidenceRaw === "number" && Number.isFinite(confidenceRaw) ? confidenceRaw : undefined;
+    const withConfidence = (answer) => (confidence === undefined ? answer : { ...answer, confidence });
+    if (question.kind === "noul") {
+        if (typeof value !== "boolean")
+            return undefined;
+        return withConfidence({ kind: "noul", value });
+    }
+    if (question.kind === "choice") {
+        if (typeof value !== "string" || !Object.hasOwn(question.options, value))
+            return undefined;
+        return withConfidence({ kind: "choice", value });
+    }
+    // ONE reading: a score is a 0-based index into the `criteria` array that was asked about, and `level` carries the
+    // string so a caller never indexes the number itself.
+    //
+    // The first draft accepted both a 0-based and a 1-based reading "because the documentation shows neither", which
+    // pushed the ambiguity onto the caller and into the ledger: with three levels, 1 and 2 were valid under both, so
+    // `levels[value]` could read "high" where the model meant "mid". An advisor exists to remove that guess, not to
+    // relocate it. **The 0-based reading is an assumption** — it indexes the documented array form — and it is
+    // unverified for the same reason everything else about the response is: no live call has been made. If Jev is
+    // 1-based, its top level falls outside the array and the whole answer is refused as unrecognised, which is the
+    // loud failure rather than a silently shifted one, and the `PI_DADDY_IT_JEV=1` tier is what would show it.
+    if (typeof value !== "number" || !Number.isInteger(value))
+        return undefined;
+    if (value < 0 || value >= question.levels.length)
+        return undefined;
+    return withConfidence({ kind: "score", value, level: question.levels[value] });
+}
+export function parseAdvice(request, body) {
+    if (typeof body !== "object" || body === null)
+        return null;
+    const envelope = body;
+    const raw = envelope.answers;
+    if (typeof raw !== "object" || raw === null)
+        return null;
+    const answers = {};
+    for (const [key, question] of Object.entries(request.questions)) {
+        const parsed = parseAnswer(question, raw[key]);
+        // Every question or none: a caller that asked two questions and silently received one would have to guess which
+        // of its branches the missing answer belonged to, and guessing is what an advisor exists to remove.
+        if (!parsed)
+            return null;
+        answers[key] = parsed;
+    }
+    return { answers, ...(typeof envelope.model === "string" ? { model: envelope.model } : {}) };
+}
+export function jevDecider(config) {
+    return {
+        name: "jev",
+        async decide(request, signal) {
+            const send = config.fetch ?? globalThis.fetch;
+            const response = await send(config.endpoint ?? JEV_ENDPOINT, {
+                method: "POST",
+                headers: { "content-type": "application/json", authorization: `Bearer ${config.apiKey}` },
+                body: JSON.stringify(wireRequest(request, config.model ?? JEV_MODEL)),
+                ...(signal ? { signal } : {}),
+            });
+            // A dead endpoint and an advisor with nothing to say must not read alike in the ledger: the whole reason for
+            // recording the nothing-cases is that an advisor which quietly stopped answering should not look like one
+            // nobody called. Thrown, so `createAdvisor` records `error` rather than `declined`; it catches, so nothing
+            // reaches the caller but `null` either way.
+            if (!response.ok)
+                throw new Error(`advisor endpoint returned ${response.status}`);
+            try {
+                return parseAdvice(request, await response.json());
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+//# sourceMappingURL=jev.js.map

package/dist/advisors/jev.js.map

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

package/dist/advisors/settings.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Whether an advisor is on, and which one (ADR-0077).
+ *
+ * **Default off, and only the environment can turn it on.** An advisor sends a description of the caller's
+ * situation to a third party, so enabling one is `PI_DADDY_ADVISOR=jev` plus a key — both outside the workspace,
+ * both stripped from every child.
+ *
+ * 0.34.0 read the enable from `.pi/pi-daddy/settings.json` and that was wrong for the reason `grant-store.ts`
+ * states about the same file: it is writable by any child holding `tool:write`, so it is "the reviewable record of
+ * the decision, not the thing the enforcer reads". A grant lives outside the workspace precisely so a child cannot
+ * widen the next session's ceiling; an advisor switch a child could flip would make the operator's next session
+ * ship its own description to a third party, which is the same self-defeating shape. The settings block may still
+ * NARROW — a shorter timeout, or `enabled: false` to turn an advisor off for one project — and can never turn one
+ * on, choose its model, or lengthen its bound. A model is a destination rather than a narrowing, so `model` in the
+ * block is refused with a message naming `PI_DADDY_ADVISOR_MODEL`, and a timeout is clamped to the default rather
+ * than trusted. Malformed configuration disables the advisor and says so: a typo must not be a way to enable anything.
+ *
+ * **Not a dashboard toggle**, which is what the programme originally sketched. The dashboard is a read-only
+ * renderer in a separate process that "never affects enforcement" (ADR-0036), and a control there that wrote to
+ * settings would be the first thing it ever wrote. Turning an advisor on is an operator decision that belongs in
+ * the reviewable file; `/grants` reports what is in force. That is a deliberate departure from the roadmap line.
+ *
+ * The key is never in the settings file either, because that file is committed and an API key must not be.
+ */
+export { ENV_ADVISOR_KEY as ADVISOR_KEY_ENV } from "../kernel/env-names.ts";
+export { ENV_ADVISOR_MODEL } from "../kernel/env-names.ts";
+export { ENV_ADVISOR } from "../kernel/env-names.ts";
+export interface AdvisorSettings {
+    enabled: boolean;
+    /** The only decider this release knows besides the null one. */
+    decider: "none" | "jev";
+    /** Overrides the adapter's pinned model id; absent means the adapter's own default. */
+    model?: string;
+    timeoutMs?: number;
+    /** Why an advisor is off when the settings asked for one on — reported, never silently applied. */
+    refusal?: string;
+}
+export declare const ADVISOR_OFF: AdvisorSettings;
+/**
+ * Read the `advisor` block of a project settings file. Absent is off; malformed is off WITH a reason.
+ *
+ * The reason matters more than it looks: an operator who wrote `"enabeld": true` and got silence would conclude the
+ * feature does not work, and an operator who wrote it and got an advisor anyway would have a third party reading
+ * their session without having successfully asked for it. Both are worse than a sentence naming the field.
+ */
+export declare function advisorSettingsFrom(raw: unknown, env?: NodeJS.ProcessEnv): AdvisorSettings;
+//# sourceMappingURL=settings.d.ts.map

package/dist/advisors/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/advisors/settings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EAAE,eAAe,IAAI,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,gEAAgE;IAChE,OAAO,EAAE,MAAM,GAAG,KAAK,CAAC;IACxB,uFAAuF;IACvF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mGAAmG;IACnG,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,WAAW,EAAE,eAAoE,CAAC;AAE/F;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,eAAe,CA4DvG"}