@smartmemory/compose 0.4.1 → 0.5.1

package/lib/canon-guard.js

@@ -98,14 +98,9 @@ export function realpathCanonicalize(p) {
  * @param {string} [args.featuresDir='docs/features']
  * @param {(p:string)=>string} [args.canonicalize] - map a path to its real, alias-free form.
  *   The runtime wrapper passes realpathCanonicalize; pure tests inject a stub or omit it.
- * @param {string} [args.profile] - the caller's MCP profile (COMPOSE_SESSION_PROFILE).
- *   Only changes the ESCAPE SENTENCE of the deny message, never the verdict:
- *   `canon_override_grant` is denied to restricted profiles by IMPLEMENTER_DENY /
- *   REVIEWER_ALLOW, so telling a restricted caller to mint a grant sends it to a
- *   tool it cannot call. Absent/unknown → the unrestricted wording (fail-open).
  * @returns {{deny: boolean, reason?: string, path?: string}}
  */
-export function decideCanonGuard({ toolName, toolInput, cwd, projectRoot, featuresDir = 'docs/features', canonicalize, profile } = {}) {
+export function decideCanonGuard({ toolName, toolInput, cwd, projectRoot, featuresDir = 'docs/features', canonicalize } = {}) {
   try {
     if (!GUARDED_TOOLS.has(toolName)) return { deny: false };
     const raw = toolInput && (toolInput.file_path ?? toolInput.notebook_path);
@@ -126,33 +121,17 @@ export function decideCanonGuard({ toolName, toolInput, cwd, projectRoot, featur
     const entry = matchEntry(relPosix, { featuresDir, point: 'hook' });
     if (!entry) return { deny: false };
 
-    // Classification only — this function stays pure. The atomic claim happens
-    // in the hook wrapper, because a destructive callback here would make the
-    // verdict depend on how many times it was evaluated.
-    const overrideEligible = entry.overrideEligible !== false;
     const tools = entry.tools.join(', ');
-    // COMP-COVERAGE-GATE C4: canon_override_grant is now denied to restricted
-    // profiles, so pointing one at it would loop it against its own tool gate.
-    const restricted = profile === 'implementer' || profile === 'reviewer';
-    const escape = !overrideEligible
-      ? `This path is the override's own governance state, so it cannot be overridden: a bypass `
-        + `must not be able to authorise rewriting its own record.`
-      : restricted
-        ? `A canon override exists, but canon_override_grant is not available to the '${profile}' `
-          + `profile — the session subject to canon enforcement cannot exempt itself from it. `
-          + `Escalate: report what you need to write and why, and let the orchestrator decide.`
-        : `To do it deliberately anyway, mint a single-use grant with canon_override_grant `
-          + `({ path, reason, operation }) — the bypass is recorded before the grant exists.`;
 
     return {
       deny: true,
       path: relPosix,
-      overrideEligible,
       reason:
         `${relPosix} is tool-owned canon (COMP-CANON-GUARD). A direct ${toolName} is blocked — `
         + `write it through one of: ${tools}. These tools stamp provenance and regenerate the `
         + `projections from records; a hand-edit is unattributed and overwritten on the next regen. `
-        + `${escape}`,
+        + `For an exceptional repair, use an authorized write outside this hook's reach; a restricted `
+        + `agent must escalate.`,
     };
   } catch {
     return { deny: false }; // fail open — never wedge the session

package/lib/canon-registry.js

@@ -19,10 +19,10 @@
  *     (open a preserved section; edit a feature description — Decision 2), so
  *     the always-deny hook would lock them out. They stay ['ship'] (their
  *     existing build-event correlation) until update_feature_fields /
- *     open_preserved_section + the override land.
+ *     open_preserved_section land.
  *
  * Adding a path here turns on real enforcement — register a path for 'hook'
- * ONLY once every legal mutation of it has a tool or an override.
+ * ONLY once every legal mutation of it has a typed tool.
  */
 
 // ── Tool sets ────────────────────────────────────────────────────────────────
@@ -30,8 +30,6 @@
 // contract test pins these against the legacy values.
 const TOOLS_FOR_ROADMAP = ['add_roadmap_entry', 'set_feature_status', 'propose_followup'];
 const TOOLS_FOR_CHANGELOG = ['add_changelog_entry'];
-/** The override's governance state is written only by the grant tool itself. */
-const TOOLS_FOR_OVERRIDE = ['canon_override_grant'];
 const TOOLS_FOR_FEATURE_JSON = [
   'add_roadmap_entry',
   'set_feature_status',
@@ -94,14 +92,6 @@ function matchJudgment(path) {
   return typeof path === 'string' && path.startsWith('docs/judgment/');
 }
 
-/**
- * Prefix match on a directory, requiring the separator so that a sibling with
- * a longer name (`canon-grants-backup/`) cannot masquerade as a child.
- */
-function matchUnder(dir) {
-  return (path) => typeof path === 'string' && path.startsWith(`${dir}/`);
-}
-
 // ── The registry ─────────────────────────────────────────────────────────────
 
 /**
@@ -111,9 +101,6 @@ function matchUnder(dir) {
  * @property {string} writer        — the module that legitimately produces this path
  * @property {string[]} tools       — typed tools authorised to write it
  * @property {Array<'ship'|'hook'|'pre-commit'>} enforcedBy — points that guard it
- * @property {boolean} [overrideEligible] — may a canon override be granted FOR
- *   this path? Absent means yes. Set false for the override's own governance
- *   state, which must be guarded without being grantable.
  * @property {(path:string, featuresDir:string)=>boolean} matches
  */
 
@@ -151,44 +138,6 @@ const REGISTRY = [
     enforcedBy: ['hook'],
     matches: (path) => matchJudgment(path),
   },
-
-  // ── Governance class (COMP-CANON-OVERRIDE S1) ──────────────────────────────
-  // The override's own state. Guarded like any canon, and additionally
-  // `overrideEligible: false` so the override cannot be turned on itself:
-  // without this, "hook-registered" and "grantable" are the same set, and an
-  // agent could grant a bypass FOR the bypass ledger and then rewrite it
-  // (gate round 2, finding 2). The grant directory is governance state for the
-  // same reason — unregistered, a raw-written token would be consumable with
-  // no ledger row at all (finding 1).
-  //
-  // Runtime-scoped, like every hook guarantee: `Bash` never reaches this.
-  {
-    id: 'override-ledger',
-    display: '.compose/canon-overrides.jsonl',
-    writer: 'lib/canon-override.js',
-    tools: TOOLS_FOR_OVERRIDE,
-    enforcedBy: ['hook'],
-    overrideEligible: false,
-    matches: matchExact('.compose/canon-overrides.jsonl'),
-  },
-  {
-    id: 'override-attest',
-    display: '.compose/canon-overrides-attest.json',
-    writer: 'lib/canon-override.js',
-    tools: TOOLS_FOR_OVERRIDE,
-    enforcedBy: ['hook'],
-    overrideEligible: false,
-    matches: matchExact('.compose/canon-overrides-attest.json'),
-  },
-  {
-    id: 'override-grants',
-    display: '.compose/data/canon-grants/**',
-    writer: 'lib/canon-override.js',
-    tools: TOOLS_FOR_OVERRIDE,
-    enforcedBy: ['hook'],
-    overrideEligible: false,
-    matches: matchUnder('.compose/data/canon-grants'),
-  },
 ];
 
 // ── Public API ───────────────────────────────────────────────────────────────
@@ -215,19 +164,6 @@ export function isGuarded(path, opts) {
   return matchEntry(path, opts) !== null;
 }
 
-/**
- * True if a canon override may be granted for `path` at `point`.
- *
- * Deliberately NOT the same predicate as `isGuarded`. Two paths are guarded
- * but ungrantable:
- *   - governance state (`overrideEligible: false`) — else the override could
- *     authorise rewriting its own audit trail;
- *   - anything not guarded at THIS point — a grant for a ship-only path is
- *     meaningless, because the hook already allows it, and would write a
- *     misleading bypass row.
- * An unguarded path is likewise ineligible: nothing is blocking it, so there
- * is nothing to override (the lockout invariant).
- */
 /**
  * Human-readable path patterns guarded at `point`, for status and help output.
  * Derived rather than hand-written: a hardcoded string in `compose guard
@@ -237,11 +173,6 @@ export function guardedDisplaysFor(point) {
   return REGISTRY.filter((e) => e.enforcedBy.includes(point)).map((e) => e.display);
 }
 
-export function isOverrideEligible(path, opts) {
-  const entry = matchEntry(path, opts);
-  return entry !== null && entry.overrideEligible !== false;
-}
-
 /** The typed tools authorised to write `path` at `point`, or [] if unguarded. */
 export function toolsForPath(path, opts) {
   const entry = matchEntry(path, opts);

package/lib/codex-preflight.js

@@ -83,6 +83,10 @@ export async function preflightCodexWorktreeProbe({
   dataDir,
   ts,
   force = false,
+  // COMP-BUILD-CANCEL C36: the build-level cancel signal. A second abort source alongside
+  // this probe's own 180s timer, so an abort during the probe stops it instead of leaving
+  // the build unreachable for up to three minutes.
+  signal = null,
 }) {
   if (process.env.COMPOSE_SKIP_CODEX_PROBE) {
     return { ok: true, skipped: true, reason: 'COMPOSE_SKIP_CODEX_PROBE set — probe skipped' };
@@ -127,6 +131,9 @@ export async function preflightCodexWorktreeProbe({
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), PROBE_AGENT_TIMEOUT_MS);
       timer.unref?.();
+      const onBuildCancel = () => controller.abort();
+      if (signal?.aborted) controller.abort();
+      else signal?.addEventListener('abort', onBuildCancel, { once: true });
       try {
         await stratum.runAgentText('codex', prompt, {
           cwd: wtPath,
@@ -141,6 +148,7 @@ export async function preflightCodexWorktreeProbe({
         });
       } finally {
         clearTimeout(timer);
+        signal?.removeEventListener('abort', onBuildCancel);
       }
     } catch (err) {
       if (['CANCELLATION_UNCONFIRMED', 'CANCELLATION_TEARDOWN_TIMEOUT'].includes(err?.code)) {

package/lib/colleague/context.js

@@ -93,6 +93,129 @@ function discussionText(idea) {
   return `Recent discussion on ${idea.handle}:\n${lines.join('\n')}`;
 }
 
+/**
+ * Project composed blocks into the shape Maya actually accepts.
+ *
+ * Maya's schema is flat `List[Dict[str, str]]` and `lib/maya-client.js` sends
+ * `channel_context` verbatim, so ANY extra key on a block is sent too. This
+ * exists because the route previously handed `context.blocks` straight to the
+ * client: once portfolio blocks gained a nested `source`, that field went to
+ * Maya unannounced — and the test that was supposed to catch it built the
+ * projection itself instead of reading what production sends, so it passed.
+ *
+ * The identity is not lost by the strip: `composePortfolioContext` writes it
+ * into `text` as well, precisely so it survives here.
+ *
+ * @param {Array<{author: string, text: string}>} blocks
+ * @returns {Array<{author: string, text: string}>}
+ */
+export function toMayaContext(blocks) {
+  return (blocks ?? []).map(({ author, text }) => ({ author, text }));
+}
+
+/**
+ * Compose the per-turn context for a PORTFOLIO turn (COMP-FOH FOH-7).
+ *
+ * Separate from `composeColleagueContext` on purpose. The project-scoped path is
+ * unchanged and must stay byte-identical — this is an additional shape, not a
+ * widened one, so that a portfolio bug can never degrade the ordinary turn.
+ *
+ * THE TWO PROJECTIONS
+ * -------------------
+ * Each block carries a structured `source` for the panel, AND repeats that
+ * identity inside `text`. Both are required, for different consumers:
+ *
+ *   - The panel groups by `block.source`, which it can only do if the field is
+ *     structured.
+ *   - Maya's schema is flat `List[Dict[str, str]]` and `lib/maya-client.js` sends
+ *     `channel_context` verbatim, so a nested `source` would not survive. If the
+ *     identity lived ONLY in that field, the flat projection would hand Maya two
+ *     identical handles from two products with nothing to tell them apart — and
+ *     a test asserting "no nested source reaches Maya" would pass while doing it.
+ *     So the identity is written into the prose, where the flat projection keeps
+ *     it.
+ *
+ * @param {{text: string}} turn
+ * @param {{recallAcross: Function, portfolio?: object, limit?: number}} deps
+ * @returns {Promise<{blocks: Array<{author, text, source}>, omissions: string[]}>}
+ */
+export async function composePortfolioContext(turn, {
+  recallAcross, portfolio = null, limit, byteBudget = DEFAULT_BYTE_BUDGET,
+} = {}) {
+  const query = String(turn?.text ?? '').trim();
+  const result = await recallAcross(portfolio, query, limit ? { limit } : {});
+
+  const omissions = [...result.omissions];
+
+  // A FAIR share per source, and every trim NAMED.
+  //
+  // Without a budget the portfolio silently answers for fewer products than it
+  // shows: Maya caps the context section and keeps a prefix, so with enough
+  // members the later products are discarded upstream while the panel still
+  // reports every source as sent. That is this feature's core failure mode
+  // reached from the inside — a partial answer that looks complete.
+  //
+  // Split evenly rather than first-come, because a budget consumed in order
+  // privileges whichever product happens to sort first and starves the rest
+  // for a reason no reader could infer.
+  const share = result.sources.length
+    ? Math.floor(byteBudget / result.sources.length)
+    : byteBudget;
+
+  const blocks = result.sources.map((source) => {
+    const how = source.listedNotSearched
+      ? 'listed, not searched — this product could not run a query'
+      : 'matching this question';
+    const header = `From ${source.id} (${source.root}) — ${how}:`;
+
+    const lines = [];
+    // The HEADER counts. With a small share (or a long root) the header alone
+    // could exceed it and still be emitted, so the "budget" was advisory — and
+    // the test that claimed it held allowed 20% overage, which made the claim
+    // unfalsifiable rather than true.
+    let used = Buffer.byteLength(header, 'utf8');
+    let dropped = 0;
+    const headerOverflowed = used > share;
+    for (const h of source.hits) {
+      const line = headline(h.record ?? h);
+      const cost = Buffer.byteLength(line, 'utf8') + 1;
+      if (used + cost > share) { dropped += 1; continue; }
+      lines.push(line);
+      used += cost;
+    }
+    if (dropped) {
+      omissions.push(
+        `${source.id} truncated to ${lines.length} of ${source.hits.length} results, over budget`,
+      );
+    } else if (headerOverflowed) {
+      // Nothing was dropped only because there was nothing to drop; the source
+      // still did not fit, and a silent over-budget source is the failure this
+      // budget exists to prevent.
+      omissions.push(`${source.id} over budget before any result could be included`);
+    }
+
+    // The body must be honest on its own. Omissions travel to the PANEL, not
+    // into Maya's context — so a source whose results were all dropped would
+    // otherwise tell the model "(nothing)", i.e. that this product has no
+    // matching ideas, which is the opposite of what happened.
+    const body = lines.length
+      ? lines.join('\n')
+      : (source.hits.length
+        ? `(${source.hits.length} result(s) omitted here — too large for this turn's share of the context)`
+        : '(nothing)');
+
+    return {
+      author: 'compose:portfolio',
+      // The source identity lives in the prose because the flat projection to
+      // Maya keeps only `author` and `text`.
+      text: `${header}\n${body}`,
+      source: { id: source.id, root: source.root },
+    };
+  });
+
+  return { blocks, omissions };
+}
+
 /**
  * Compose the per-turn context for a colleague turn.
  *