@telora/mcp-products 0.22.104 → 0.22.107

package/dist/handlers/auditTreeAuthoringGuide.d.ts

@@ -1 +1 @@
-export declare const AUDIT_TREE_AUTHORING_GUIDE = "# Audit Tree-Authoring Protocol (CRT -> injections -> anchored plan)\n\nA safe audit emits a **tree and a plan, never a task checklist.** You are\nREAD-ONLY: discovery only. You author the intent structure -- the current\nreality, its root causes, and the leverage points -- and you anchor a plan a\nhuman reviews before any fix runs. You do NOT fix anything, and you do NOT\nfile remediation Task/Bug issues. Remediation is scoped LATER, one root cause\nat a time, from the injections you ratify here -- so there is no flat checklist\nto complete with completion-vigor and churn stays bounded to the real defects.\n\nTwo artifacts, one purpose:\n- **CRT (current reality)** -- entities + undesired effects (UDEs) wired by\n  causal edges, surfacing the systemic structure so cross-area root causes\n  become visible in ONE focus tree (NOT one delivery per audit area).\n- **FRT (future reality)** -- injections at the root causes, self-validated to\n  confirm they flip the UDEs, then anchored to planning deliveries whose\n  acceptance is the future-state desired effect each injection produces.\n\n## Rounds (distinct jobs -- not \"find more\")\n1. **Facts -> CRT.** Author the current reality. Create the focus's reality\n   tree if none exists (`telora_reality_tree action=create`), then add an\n   **entity** node per real component/observation and an **undesired_effect**\n   (UDE) node per observed problem (`telora_reality_tree_node action=create`).\n   State what IS, in evidence terms -- not a fix.\n2. **Relationships -> causal edges.** Wire cause -> effect with\n   `telora_reality_tree_edge action=create` (cause node -> effect node). This\n   is the load-bearing round: edges turn a list of symptoms into a causal\n   structure, so a single deep cause feeding many surface UDEs across different\n   audit areas becomes visible as ONE root in ONE tree -- which is exactly what\n   stops the \"one delivery per area\" sprawl.\n3. **Leverage -> injections.** Propose **injection** nodes at the LOWEST / root\n   causes (the nodes with the most downstream UDEs), not at the symptoms.\n   One injection at a root can clear a whole subtree of UDEs; that leverage is\n   the whole reason for the tree.\n4. **Self-validate -> derive_frt.** Call\n   `telora_reality_tree action=derive_frt` with the treeId. This is read-only:\n   it returns the cleared/flipped UDE sets the injections produce. Confirm each\n   injection flips the UDEs you targeted. If a UDE is left unresolved by your\n   injection set, REPORT it -- do not hide it and do not lower the bar to make\n   the tree look clean. An honest \"this UDE has no injection yet\" is signal; a\n   silently dropped UDE is noise.\n5. **Anchor the plan -> injection-anchored deliveries.** For each ratified\n   injection, create a remediation delivery with\n   `telora_product_delivery action=create`, passing\n   `injectionNodeId=<the injection node>` and\n   `executionStatus=\"planning\"`. Set its acceptance to the **FRT desired\n   effect** -- the future-state the injection produces (what becomes true once\n   the root cause is cleared), NOT a list of edits. This is the navigable plan\n   the human reviews in the canvas before anything executes.\n\nExplicitly, in the audit phase your output is **the tree + the anchored\nplanning deliveries only.** Do NOT create remediation Task or Bug issues. Do\nNOT create one delivery per audit area -- unify the audit into ONE focus tree\nand let each injection (each root cause) anchor exactly one planning delivery.\nDo NOT attempt fixes.\n\n## Statement quality (Goldratt Categories of Legitimate Reservation)\nHold every node to three statement-quality reservations AS YOU WRITE IT --\ninline with the rounds above, not a separate pass:\n- **Clarity.** Each statement is ONE unambiguous declarative sentence that\n  reads standalone -- no jargon or pronoun a reviewer must guess at.\n- **Entity Existence.** Each entity / UDE names a COMPLETE, REAL state that\n  actually exists, not a sentence fragment or a vague gesture. Prefer a\n  grounded observation over an invented abstraction.\n- **Tautology.** In the relationships round, no cause -> effect pair may be\n  circular: an effect must NOT be offered as the reason its own cause exists.\n\nA node that fails any of these radiates unearned certainty; fix the statement\nbefore you wire it. These reservations cost no extra call -- they are how you\nwrite each node, not a gate you run afterward.\n\n## Two hard integrity gates (deterministic; a tree must pass to present)\nThe tree dump (`telora_reality_tree action=dump`) computes and surfaces two\ndeterministic doubt-revealer gates near its header, so unearned certainty\ncannot hide:\n- **Connectivity (NO ORPHANS).** A node with zero edges of ANY type AND no\n  `evidence` is an ORPHAN -- it floats, neither wired into the causal graph nor\n  folded into its own evidence. A single orphan makes the tree **NOT\n  presentable**; the dump names the orphan seqs. Fix it: wire the node to a\n  cause/effect with an edge, or ground it by setting `evidence`. An orphan is\n  reality with nothing to measure it against -- it must not survive to review.\n- **Evidence-or-assumed.** An `entity` / `undesired_effect` with empty/null\n  `evidence` renders an `[assumed]` marker; with evidence it renders\n  `(evidence)`. Assumed is NOT a violation -- it is an honest hedge that the\n  claim is unearned certainty until grounded. Set `evidence` on the nodes you\n  can actually observe; leave the rest visibly `[assumed]` rather than dressing\n  a guess up as a proven cause.\n\n## Why this shape (the discipline it enforces)\nA flat checklist invites an agent to \"complete\" it -- to keep going until every\nbox is ticked, which churns code well beyond the real defects. An\ninjection-anchored plan inverts that: remediation is scoped one root cause at a\ntime from a ratified injection, with acceptance pinned to a desired effect, so\nthere is nothing to over-complete. The human reviews the structured CRT + FRT\nin the canvas first, so a wrong root cause is caught before any code moves.";
+export declare const AUDIT_TREE_AUTHORING_GUIDE = "# Audit Tree-Authoring Protocol (CRT -> injections -> anchored plan)\n\nA safe audit emits a **tree and a plan, never a task checklist.** You are\nREAD-ONLY: discovery only. You author the intent structure -- the current\nreality, its root causes, and the leverage points -- and you anchor a plan of\ninjection-anchored remediation deliveries. You do NOT fix anything, and you do\nNOT file remediation Task/Bug issues. Remediation is scoped LATER, one root\ncause at a time, from the injections you anchor here -- so there is no flat\nchecklist to complete with completion-vigor and churn stays bounded to the real\ndefects.\n\nWhat happens to the deliveries you anchor depends on the focus posture, so do\nnot assume a human gate that may not exist:\n- On a **read-only audit focus**, the anchored deliveries rest at `planning`\n  behind the human ratify gate -- a human reviews the plan and ratifies it\n  before anything executes.\n- On a **live, past-planning focus**, the anchored deliveries are created\n  `queued` and execute AUTONOMOUSLY through the normal review gate -- there is\n  no human step before they run.\n\nEither way, if you believe the work must NOT run, that belief goes to an\nescalation (`telora_agent action=escalate`), never into a delivery's\nacceptance criteria.\n\nTwo artifacts, one purpose:\n- **CRT (current reality)** -- entities + undesired effects (UDEs) wired by\n  causal edges, surfacing the systemic structure so cross-area root causes\n  become visible in ONE focus tree (NOT one delivery per audit area).\n- **FRT (future reality)** -- injections at the root causes, self-validated to\n  confirm they flip the UDEs, then anchored to planning deliveries whose\n  acceptance is the future-state desired effect each injection produces.\n\n## Rounds (distinct jobs -- not \"find more\")\n1. **Facts -> CRT.** Author the current reality. Create the focus's reality\n   tree if none exists (`telora_reality_tree action=create`), then add an\n   **entity** node per real component/observation and an **undesired_effect**\n   (UDE) node per observed problem (`telora_reality_tree_node action=create`).\n   State what IS, in evidence terms -- not a fix.\n2. **Relationships -> causal edges.** Wire cause -> effect with\n   `telora_reality_tree_edge action=create` (cause node -> effect node). This\n   is the load-bearing round: edges turn a list of symptoms into a causal\n   structure, so a single deep cause feeding many surface UDEs across different\n   audit areas becomes visible as ONE root in ONE tree -- which is exactly what\n   stops the \"one delivery per area\" sprawl.\n3. **Leverage -> injections.** Propose **injection** nodes at the LOWEST / root\n   causes (the nodes with the most downstream UDEs), not at the symptoms.\n   One injection at a root can clear a whole subtree of UDEs; that leverage is\n   the whole reason for the tree.\n4. **Self-validate -> derive_frt.** Call\n   `telora_reality_tree action=derive_frt` with the treeId. This is read-only:\n   it returns the cleared/flipped UDE sets the injections produce. Confirm each\n   injection flips the UDEs you targeted. If a UDE is left unresolved by your\n   injection set, REPORT it -- do not hide it and do not lower the bar to make\n   the tree look clean. An honest \"this UDE has no injection yet\" is signal; a\n   silently dropped UDE is noise.\n5. **Anchor the plan -> injection-anchored deliveries.** For each injection,\n   create a remediation delivery with\n   `telora_product_delivery action=create`, passing\n   `injectionNodeId=<the injection node>` and `executionStatus=\"planning\"`.\n   Set its acceptance to the **FRT desired effect** -- the future-state the\n   injection produces (what becomes true once the root cause is cleared), NOT a\n   list of edits and NOT process instructions.\n\nExplicitly, in the audit phase your output is **the tree + the anchored\nplanning deliveries only.** Do NOT create remediation Task or Bug issues. Do\nNOT create one delivery per audit area -- unify the audit into ONE focus tree\nand let each injection (each root cause) anchor exactly one planning delivery.\nDo NOT attempt fixes.\n\n## Acceptance criteria carry the future state ONLY -- never a hold\nA remediation delivery's acceptanceCriteria state ONLY the **FRT desired\neffect**: the future-state that becomes true once the root cause is cleared.\nAcceptanceCriteria are NOT workflow state and NOT a channel to a human. Never\nwrite into acceptanceCriteria:\n- process instructions or step-by-step directions to the executing team,\n- a hold, a pause, or an approval requirement (e.g. \"HOLD FOR HUMAN REVIEW\n  BEFORE EXECUTING\", \"do not execute until ...\", \"wait for sign-off\"),\n- status commentary or notes about what you think should happen next.\n\nProse is invisible to the workflow: a hold written into acceptanceCriteria\ngates nothing, and on a live focus the executing team either obeys a stop the\nmachine never enforces or is misled by an instruction it should never have been\ngiven. If you believe the work must NOT run yet -- a dependency is missing, or\nthe decision needs human intent -- the ONLY channel for that belief is an\nescalation via `telora_agent action=escalate`. Raise the doubt as an\nescalation; never encode it as acceptance-criteria text.\n\n## Statement quality (Goldratt Categories of Legitimate Reservation)\nHold every node to three statement-quality reservations AS YOU WRITE IT --\ninline with the rounds above, not a separate pass:\n- **Clarity.** Each statement is ONE unambiguous declarative sentence that\n  reads standalone -- no jargon or pronoun a reviewer must guess at.\n- **Entity Existence.** Each entity / UDE names a COMPLETE, REAL state that\n  actually exists, not a sentence fragment or a vague gesture. Prefer a\n  grounded observation over an invented abstraction.\n- **Tautology.** In the relationships round, no cause -> effect pair may be\n  circular: an effect must NOT be offered as the reason its own cause exists.\n\nA node that fails any of these radiates unearned certainty; fix the statement\nbefore you wire it. These reservations cost no extra call -- they are how you\nwrite each node, not a gate you run afterward.\n\n## Two hard integrity gates (deterministic; a tree must pass to present)\nThe tree dump (`telora_reality_tree action=dump`) computes and surfaces two\ndeterministic doubt-revealer gates near its header, so unearned certainty\ncannot hide:\n- **Connectivity (NO ORPHANS).** A node with zero edges of ANY type AND no\n  `evidence` is an ORPHAN -- it floats, neither wired into the causal graph nor\n  folded into its own evidence. A single orphan makes the tree **NOT\n  presentable**; the dump names the orphan seqs. Fix it: wire the node to a\n  cause/effect with an edge, or ground it by setting `evidence`. An orphan is\n  reality with nothing to measure it against -- it must not survive to review.\n- **Evidence-or-assumed.** An `entity` / `undesired_effect` with empty/null\n  `evidence` renders an `[assumed]` marker; with evidence it renders\n  `(evidence)`. Assumed is NOT a violation -- it is an honest hedge that the\n  claim is unearned certainty until grounded. Set `evidence` on the nodes you\n  can actually observe; leave the rest visibly `[assumed]` rather than dressing\n  a guess up as a proven cause.\n\n## Why this shape (the discipline it enforces)\nA flat checklist invites an agent to \"complete\" it -- to keep going until every\nbox is ticked, which churns code well beyond the real defects. An\ninjection-anchored plan inverts that: remediation is scoped one root cause at a\ntime from an injection, with acceptance pinned to a desired effect, so there is\nnothing to over-complete. The structured CRT + FRT make a wrong root cause\nlegible as a plan -- catchable up front rather than only after code has moved.";

package/dist/handlers/auditTreeAuthoringGuide.js

@@ -6,35 +6,28 @@
 //
 // The job of a safe audit is to emit a navigable PLAN -- a Current Reality Tree
 // (CRT) plus a Future Reality Tree (FRT) of proposed injections, anchored to
-// remediation deliveries a human reviews BEFORE any fix executes. The failure
-// mode this kills: a flat task checklist the agent completes with
+// remediation deliveries. What happens to those deliveries depends on the focus
+// POSTURE, and this guide states BOTH cases rather than promising a human gate
+// that may not exist: on a read-only audit focus they rest at planning behind
+// the human ratify gate; on a live, past-planning focus they queue and execute
+// autonomously. telora_discover has no posture at load time, so the guide
+// cannot narrow to one -- it must be honest about both. The failure mode this
+// kills: an assessor told the read-only model on a live focus manufactures the
+// missing hold in prose, and a flat task checklist the agent completes with
 // completion-vigor, churning code well past the real defects.
 //
-// SOURCE OF TRUTH: this constant is also mirrored verbatim into the daemon's
-// audit assessor prompt (packages/daemon/src/audit-phase.ts AUDIT_PROMPT). The
+// SOURCE OF TRUTH for the posture-neutral discipline (the AUDIT_GUIDE_SHARED
+// const below) is mirrored verbatim into the daemon's audit assessor prompt
+// (packages/daemon/src/audit-phase.ts, the AUDIT_GUIDE_SHARED constant). The
 // daemon cannot runtime-import this MCP package (no cross-package runtime
-// import), so the prose is duplicated there with a comment pointing back here.
-// When you change this guide, update AUDIT_PROMPT to match.
+// import), so the prose is duplicated there. The required-sync invariant is
+// held MECHANICALLY, not by this comment: the daemon test audit-guide-sync.test.ts
+// extracts the text between the begin/end sentinel lines in both files and
+// fails on any drift. The sentinel lines wrap ONLY the const declaration, so
+// the extracted region is identical. Edit both, or the build goes red.
 // ---------------------------------------------------------------------------
-export const AUDIT_TREE_AUTHORING_GUIDE = `# Audit Tree-Authoring Protocol (CRT -> injections -> anchored plan)
-
-A safe audit emits a **tree and a plan, never a task checklist.** You are
-READ-ONLY: discovery only. You author the intent structure -- the current
-reality, its root causes, and the leverage points -- and you anchor a plan a
-human reviews before any fix runs. You do NOT fix anything, and you do NOT
-file remediation Task/Bug issues. Remediation is scoped LATER, one root cause
-at a time, from the injections you ratify here -- so there is no flat checklist
-to complete with completion-vigor and churn stays bounded to the real defects.
-
-Two artifacts, one purpose:
-- **CRT (current reality)** -- entities + undesired effects (UDEs) wired by
-  causal edges, surfacing the systemic structure so cross-area root causes
-  become visible in ONE focus tree (NOT one delivery per audit area).
-- **FRT (future reality)** -- injections at the root causes, self-validated to
-  confirm they flip the UDEs, then anchored to planning deliveries whose
-  acceptance is the future-state desired effect each injection produces.
-
-## Rounds (distinct jobs -- not "find more")
+// SHARED-AUDIT-GUIDE:BEGIN
+const AUDIT_GUIDE_SHARED = `## Rounds (distinct jobs -- not "find more")
 1. **Facts -> CRT.** Author the current reality. Create the focus's reality
    tree if none exists (\`telora_reality_tree action=create\`), then add an
    **entity** node per real component/observation and an **undesired_effect**
@@ -57,14 +50,13 @@ Two artifacts, one purpose:
    injection set, REPORT it -- do not hide it and do not lower the bar to make
    the tree look clean. An honest "this UDE has no injection yet" is signal; a
    silently dropped UDE is noise.
-5. **Anchor the plan -> injection-anchored deliveries.** For each ratified
-   injection, create a remediation delivery with
+5. **Anchor the plan -> injection-anchored deliveries.** For each injection,
+   create a remediation delivery with
    \`telora_product_delivery action=create\`, passing
-   \`injectionNodeId=<the injection node>\` and
-   \`executionStatus="planning"\`. Set its acceptance to the **FRT desired
-   effect** -- the future-state the injection produces (what becomes true once
-   the root cause is cleared), NOT a list of edits. This is the navigable plan
-   the human reviews in the canvas before anything executes.
+   \`injectionNodeId=<the injection node>\` and \`executionStatus="planning"\`.
+   Set its acceptance to the **FRT desired effect** -- the future-state the
+   injection produces (what becomes true once the root cause is cleared), NOT a
+   list of edits and NOT process instructions.
 
 Explicitly, in the audit phase your output is **the tree + the anchored
 planning deliveries only.** Do NOT create remediation Task or Bug issues. Do
@@ -72,6 +64,24 @@ NOT create one delivery per audit area -- unify the audit into ONE focus tree
 and let each injection (each root cause) anchor exactly one planning delivery.
 Do NOT attempt fixes.
 
+## Acceptance criteria carry the future state ONLY -- never a hold
+A remediation delivery's acceptanceCriteria state ONLY the **FRT desired
+effect**: the future-state that becomes true once the root cause is cleared.
+AcceptanceCriteria are NOT workflow state and NOT a channel to a human. Never
+write into acceptanceCriteria:
+- process instructions or step-by-step directions to the executing team,
+- a hold, a pause, or an approval requirement (e.g. "HOLD FOR HUMAN REVIEW
+  BEFORE EXECUTING", "do not execute until ...", "wait for sign-off"),
+- status commentary or notes about what you think should happen next.
+
+Prose is invisible to the workflow: a hold written into acceptanceCriteria
+gates nothing, and on a live focus the executing team either obeys a stop the
+machine never enforces or is misled by an instruction it should never have been
+given. If you believe the work must NOT run yet -- a dependency is missing, or
+the decision needs human intent -- the ONLY channel for that belief is an
+escalation via \`telora_agent action=escalate\`. Raise the doubt as an
+escalation; never encode it as acceptance-criteria text.
+
 ## Statement quality (Goldratt Categories of Legitimate Reservation)
 Hold every node to three statement-quality reservations AS YOU WRITE IT --
 inline with the rounds above, not a separate pass:
@@ -108,7 +118,41 @@ cannot hide:
 A flat checklist invites an agent to "complete" it -- to keep going until every
 box is ticked, which churns code well beyond the real defects. An
 injection-anchored plan inverts that: remediation is scoped one root cause at a
-time from a ratified injection, with acceptance pinned to a desired effect, so
-there is nothing to over-complete. The human reviews the structured CRT + FRT
-in the canvas first, so a wrong root cause is caught before any code moves.`;
+time from an injection, with acceptance pinned to a desired effect, so there is
+nothing to over-complete. The structured CRT + FRT make a wrong root cause
+legible as a plan -- catchable up front rather than only after code has moved.`;
+// SHARED-AUDIT-GUIDE:END
+export const AUDIT_TREE_AUTHORING_GUIDE = `# Audit Tree-Authoring Protocol (CRT -> injections -> anchored plan)
+
+A safe audit emits a **tree and a plan, never a task checklist.** You are
+READ-ONLY: discovery only. You author the intent structure -- the current
+reality, its root causes, and the leverage points -- and you anchor a plan of
+injection-anchored remediation deliveries. You do NOT fix anything, and you do
+NOT file remediation Task/Bug issues. Remediation is scoped LATER, one root
+cause at a time, from the injections you anchor here -- so there is no flat
+checklist to complete with completion-vigor and churn stays bounded to the real
+defects.
+
+What happens to the deliveries you anchor depends on the focus posture, so do
+not assume a human gate that may not exist:
+- On a **read-only audit focus**, the anchored deliveries rest at \`planning\`
+  behind the human ratify gate -- a human reviews the plan and ratifies it
+  before anything executes.
+- On a **live, past-planning focus**, the anchored deliveries are created
+  \`queued\` and execute AUTONOMOUSLY through the normal review gate -- there is
+  no human step before they run.
+
+Either way, if you believe the work must NOT run, that belief goes to an
+escalation (\`telora_agent action=escalate\`), never into a delivery's
+acceptance criteria.
+
+Two artifacts, one purpose:
+- **CRT (current reality)** -- entities + undesired effects (UDEs) wired by
+  causal edges, surfacing the systemic structure so cross-area root causes
+  become visible in ONE focus tree (NOT one delivery per audit area).
+- **FRT (future reality)** -- injections at the root causes, self-validated to
+  confirm they flip the UDEs, then anchored to planning deliveries whose
+  acceptance is the future-state desired effect each injection produces.
+
+${AUDIT_GUIDE_SHARED}`;
 //# sourceMappingURL=auditTreeAuthoringGuide.js.map

package/dist/handlers/auditTreeAuthoringGuide.js.map

@@ -1 +1 @@
-{"version":3,"file":"auditTreeAuthoringGuide.js","sourceRoot":"","sources":["../../src/handlers/auditTreeAuthoringGuide.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,2EAA2E;AAC3E,0EAA0E;AAC1E,0EAA0E;AAC1E,gFAAgF;AAChF,EAAE;AACF,gFAAgF;AAChF,6EAA6E;AAC7E,8EAA8E;AAC9E,kEAAkE;AAClE,8DAA8D;AAC9D,EAAE;AACF,6EAA6E;AAC7E,+EAA+E;AAC/E,0EAA0E;AAC1E,+EAA+E;AAC/E,4DAA4D;AAC5D,8EAA8E;AAE9E,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA8FkC,CAAC"}
+{"version":3,"file":"auditTreeAuthoringGuide.js","sourceRoot":"","sources":["../../src/handlers/auditTreeAuthoringGuide.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,2EAA2E;AAC3E,0EAA0E;AAC1E,0EAA0E;AAC1E,gFAAgF;AAChF,EAAE;AACF,gFAAgF;AAChF,6EAA6E;AAC7E,gFAAgF;AAChF,+EAA+E;AAC/E,8EAA8E;AAC9E,+EAA+E;AAC/E,0EAA0E;AAC1E,8EAA8E;AAC9E,+EAA+E;AAC/E,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,6EAA6E;AAC7E,4EAA4E;AAC5E,6EAA6E;AAC7E,0EAA0E;AAC1E,4EAA4E;AAC5E,mFAAmF;AACnF,2EAA2E;AAC3E,6EAA6E;AAC7E,uEAAuE;AACvE,8EAA8E;AAE9E,2BAA2B;AAC3B,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA6FoD,CAAC;AAChF,yBAAyB;AAEzB,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCxC,kBAAkB,EAAE,CAAC"}

package/dist/handlers/sessionStateHandler.js

@@ -12,9 +12,11 @@ import { callProductApi, successResult, wrapHandler, } from "../shared.js";
 export function registerSessionStateTool(server, getCreds) {
     server.tool("telora_session_state", "Session bootstrap: returns Telora connection state in a single payload " +
         "(connected URL, organization, product, active focus + role, pending " +
-        "delivery counts). Used by the SessionStart hook to surface state at " +
-        "chat open. Optional productId; auto-resolved when the organization " +
-        "has a single product. " +
+        "delivery counts). activeFocus also carries an operator-stop indicator " +
+        "(held: true + operatorStoppedAt timestamp) so a stop is confirmable " +
+        "without reading the daemon log. Used by the SessionStart hook to surface " +
+        "state at chat open. Optional productId; auto-resolved when the " +
+        "organization has a single product. " +
         "NOTE: branch state (commits ahead of integration) is NOT included in " +
         "this response -- the server has no git access. For branch state, run " +
         "`telora-daemon session-state --json` in the repo root.", {

package/dist/handlers/sessionStateHandler.js.map

@@ -1 +1 @@
-{"version":3,"file":"sessionStateHandler.js","sourceRoot":"","sources":["../../src/handlers/sessionStateHandler.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,2CAA2C;AAC3C,EAAE;AACF,sEAAsE;AACtE,0EAA0E;AAC1E,oEAAoE;AACpE,0EAA0E;AAC1E,uDAAuD;AACvD,8EAA8E;AAE9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,cAAc,EACd,aAAa,EACb,WAAW,GAEZ,MAAM,cAAc,CAAC;AAEtB,MAAM,UAAU,wBAAwB,CACtC,MAAiB,EACjB,QAAkB;IAElB,MAAM,CAAC,IAAI,CACT,sBAAsB,EACtB,yEAAyE;QACvE,sEAAsE;QACtE,sEAAsE;QACtE,qEAAqE;QACrE,wBAAwB;QACxB,uEAAuE;QACvE,uEAAuE;QACvE,wDAAwD,EAC1D;QACE,SAAS,EAAE,CAAC;aACT,MAAM,EAAE;aACR,IAAI,EAAE;aACN,QAAQ,EAAE;aACV,QAAQ,CACP,oEAAoE,CACrE;KACJ,EACD,WAAW,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE;QAClC,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;QACzB,MAAM,IAAI,GAA4B,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;QAClE,IAAI,SAAS;YAAE,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC1C,MAAM,MAAM,GAAG,CAAC,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAA4B,CAAC;QAC9E,uEAAuE;QACvE,gCAAgC;QAChC,MAAM,QAAQ,GAAG,EAAE,GAAG,MAAM,EAAE,YAAY,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;QAC9D,OAAO,aAAa,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC,CAAC,CACH,CAAC;AACJ,CAAC"}
+{"version":3,"file":"sessionStateHandler.js","sourceRoot":"","sources":["../../src/handlers/sessionStateHandler.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,2CAA2C;AAC3C,EAAE;AACF,sEAAsE;AACtE,0EAA0E;AAC1E,oEAAoE;AACpE,0EAA0E;AAC1E,uDAAuD;AACvD,8EAA8E;AAE9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,cAAc,EACd,aAAa,EACb,WAAW,GAEZ,MAAM,cAAc,CAAC;AAEtB,MAAM,UAAU,wBAAwB,CACtC,MAAiB,EACjB,QAAkB;IAElB,MAAM,CAAC,IAAI,CACT,sBAAsB,EACtB,yEAAyE;QACvE,sEAAsE;QACtE,wEAAwE;QACxE,sEAAsE;QACtE,2EAA2E;QAC3E,iEAAiE;QACjE,qCAAqC;QACrC,uEAAuE;QACvE,uEAAuE;QACvE,wDAAwD,EAC1D;QACE,SAAS,EAAE,CAAC;aACT,MAAM,EAAE;aACR,IAAI,EAAE;aACN,QAAQ,EAAE;aACV,QAAQ,CACP,oEAAoE,CACrE;KACJ,EACD,WAAW,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE;QAClC,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;QACzB,MAAM,IAAI,GAA4B,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;QAClE,IAAI,SAAS;YAAE,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC1C,MAAM,MAAM,GAAG,CAAC,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAA4B,CAAC;QAC9E,uEAAuE;QACvE,gCAAgC;QAChC,MAAM,QAAQ,GAAG,EAAE,GAAG,MAAM,EAAE,YAAY,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;QAC9D,OAAO,aAAa,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC,CAAC,CACH,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telora/mcp-products",
-  "version": "0.22.104",
+  "version": "0.22.107",
   "description": "MCP server exposing Telora product operations to Claude Code",
   "type": "module",
   "main": "dist/index.js",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@telora/daemon-core": "^0.2.69",
+    "@telora/daemon-core": "^0.2.74",
     "ts-morph": "^28.0.0",
     "zod": "^4.3.6"
   },