forge-workflow 0.1.0-beta.4 → 0.1.0-beta.5

package/lib/memory/router.js

@@ -242,6 +242,21 @@ function legacyJsonlPath(projectRoot) {
   return path.join(projectRoot, ...LEGACY_JSONL_RELATIVE);
 }
 
+function legacyTags(parsed) {
+  const tags = Array.isArray(parsed.tags)
+    ? parsed.tags.filter(tag => typeof tag === 'string')
+    : [];
+  if (
+    typeof parsed.type === 'string'
+    && /^[a-z0-9][a-z0-9-]{0,63}$/i.test(parsed.type)
+    && !tags.some(tag => tag.startsWith('type:'))
+  ) {
+    tags.push(`type:${parsed.type.toLowerCase()}`);
+  }
+  if (!tags.some(tag => tag.startsWith('trust:'))) tags.push('trust:suggested');
+  return tags;
+}
+
 // A STABLE key for a legacy record that lacks an `id`, derived from its content — so a
 // re-run (or a failed rename) upserts the same row instead of double-inserting under a
 // fresh random UUID.
@@ -292,7 +307,7 @@ function migrateJsonlNotesOnce(projectRoot, options = {}) {
       key: typeof parsed.id === 'string' && parsed.id ? parsed.id : legacyContentKey(parsed),
       value: parsed.note,
       sourceAgent: IMPORT_SOURCE_AGENT,
-      tags: Array.isArray(parsed.tags) ? parsed.tags.filter(tag => typeof tag === 'string') : [],
+      tags: legacyTags(parsed),
     };
     if (typeof parsed.timestamp === 'string' && parsed.timestamp && !Number.isNaN(Date.parse(parsed.timestamp))) {
       entry.timestamp = parsed.timestamp;

package/lib/memory-digest.js

@@ -22,6 +22,7 @@
 const { applyBudget, buildSection, estimateTokens } = require('./orientation');
 const { fenceUntrusted } = require('./untrusted-content');
 const { collectInbox, inboxSection } = require('./inbox');
+const { memoryTrustStatus } = require('./memory-recall');
 
 const DEFAULT_DIGEST_BUDGET_TOKENS = 400;
 const DEFAULT_NOTE_LIMIT = 5;
@@ -103,7 +104,13 @@ async function collectDigestData(projectRoot, opts = {}) {
 /** `- [date ]note` for a recall note. */
 function formatNoteLine(note) {
   const date = typeof note.timestamp === 'string' && note.timestamp ? `${note.timestamp.slice(0, 10)} ` : '';
-  return `- ${date}${note.note}`;
+  const trust = memoryTrustStatus({
+    tags: note.tags,
+    sourceAgent: note.sourceAgent,
+    value: note.machine ? {} : note.note,
+  });
+  const sourceAgent = note.sourceAgent || 'unknown';
+  return `- [source=${sourceAgent} trust=${trust} updated=${date.trim() || 'unknown'}] ${note.note}`;
 }
 
 /** `- [label] title` for an issue row (title/id defensively resolved). */
@@ -112,18 +119,39 @@ function formatIssueLine(label, issue) {
   return `- [${label}] ${title}`;
 }
 
-/** Build the notes section, or null when there are no notes. */
-function notesSection(notes) {
-  if (!notes.length) return null;
-  return buildSection({
-    id: 'digest_notes',
-    title: 'Remembered notes',
-    content: notes.map(formatNoteLine).join('\n'),
-    priority: 10,
-    preserve: false,
-    // Untrusted: a planted note is DATA, not instructions. Fenced after truncation.
-    untrustedSource: 'memory',
-  });
+/** Build separate confirmed/suggested note sections, skipping entries too large to fit. */
+function notesSections(notes, budgetTokens) {
+  const eligible = notes
+    .map(note => ({ note, line: formatNoteLine(note) }))
+    .filter(entry => estimateTokens(entry.line) <= budgetTokens);
+  const groups = [
+    { id: 'digest_notes', title: 'Confirmed memory', trust: 'confirmed', priority: 10 },
+    {
+      id: 'digest_suggested_memory',
+      title: 'Suggested memory — verify before relying',
+      trust: 'suggested',
+      priority: 11,
+    },
+  ];
+  return groups.map(group => {
+    const content = eligible
+      .filter(({ note }) => memoryTrustStatus({
+        tags: note.tags,
+        sourceAgent: note.sourceAgent,
+        value: note.machine ? {} : note.note,
+      }) === group.trust)
+      .map(entry => entry.line)
+      .join('\n');
+    if (!content) return null;
+    return buildSection({
+      id: group.id,
+      title: group.title,
+      content,
+      priority: group.priority,
+      preserve: false,
+      untrustedSource: 'memory',
+    });
+  }).filter(Boolean);
 }
 
 /**
@@ -161,13 +189,17 @@ function buildMemoryDigest(data = {}, options = {}) {
   const ready = Array.isArray(data.ready) ? data.ready : [];
   const claimed = Array.isArray(data.claimed) ? data.claimed : [];
   const inbox = Array.isArray(data.inbox) ? data.inbox : [];
+  const budgetTokens = options.budgetTokens || DEFAULT_DIGEST_BUDGET_TOKENS;
 
   // Inbox (priority 5) is a THIRD section beside notes + issues; a fresh human directive
   // outranks stale notes (10) and the agent's own issue list (20) under budget pressure.
-  const sections = [inboxSection(inbox), notesSection(notes), issuesSection(ready, claimed)].filter(Boolean);
+  const sections = [
+    inboxSection(inbox),
+    ...notesSections(notes, budgetTokens),
+    issuesSection(ready, claimed),
+  ].filter(Boolean);
   if (!sections.length) return { text: '', empty: true, tokens: 0 };
 
-  const budgetTokens = options.budgetTokens || DEFAULT_DIGEST_BUDGET_TOKENS;
   const budgeted = applyBudget(sections, budgetTokens);
   const body = budgeted.sections
     .filter(section => section.content)

package/lib/memory-recall-events.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const { randomUUID } = require('node:crypto');
+const { spawn } = require('node:child_process');
+
+const { resolveKernelDatabasePath } = require('./kernel/cli-broker-factory');
+const { createBuiltinSQLiteDriver } = require('./kernel/sqlite-driver');
+const projectMemory = require('./project-memory');
+
+const EVENT_TYPE = 'memory.recall.observed';
+const OUTCOMES = new Set(['selected', 'empty', 'filtered', 'unsupported', 'timeout', 'error']);
+const MAX_COUNT = 1_000_000;
+const MAX_SELECTED_IDS = 20;
+const MAX_MIX_KEYS = 10;
+const EVENT_WRITER = "const { recordMemoryRecallPayload } = require(process.argv[1]); recordMemoryRecallPayload(process.argv[2], JSON.parse(process.argv[3])).catch(() => {});";
+
+function boundedInteger(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(MAX_COUNT, Math.max(0, Math.trunc(value)));
+}
+
+function boundedString(value, maxLength) {
+  return String(value ?? '').slice(0, maxLength);
+}
+
+function boundedMix(mix) {
+  if (!mix || typeof mix !== 'object' || Array.isArray(mix)) return {};
+  return Object.fromEntries(
+    Object.entries(mix)
+      .slice(0, MAX_MIX_KEYS)
+      .map(([label, count]) => [boundedString(label, 64), boundedInteger(count)])
+      .filter(([label, count]) => label && count > 0)
+  );
+}
+
+function buildRecallEventPayload(observation = {}) {
+  const selectedIds = Array.isArray(observation.selectedIds)
+    ? observation.selectedIds
+      .slice(0, MAX_SELECTED_IDS)
+      .map(id => boundedString(id, 128))
+      .filter(Boolean)
+    : [];
+  return {
+    outcome: OUTCOMES.has(observation.outcome) ? observation.outcome : 'error',
+    counts: {
+      candidates: boundedInteger(observation.candidateCount),
+      eligible: boundedInteger(observation.eligibleCount),
+      selected: selectedIds.length,
+    },
+    selected_ids: selectedIds,
+    source_mix: boundedMix(observation.sourceMix),
+    trust_mix: boundedMix(observation.trustMix),
+    token_estimate: boundedInteger(observation.tokenEstimate),
+    elapsed_ms: boundedInteger(observation.elapsedMs),
+    harness: boundedString(observation.harness || 'unknown', 32),
+  };
+}
+
+function normalizeRecallEventPayload(payload = {}) {
+  return buildRecallEventPayload({
+    outcome: payload.outcome,
+    candidateCount: payload.counts?.candidates,
+    eligibleCount: payload.counts?.eligible,
+    selectedIds: payload.selected_ids,
+    sourceMix: payload.source_mix,
+    trustMix: payload.trust_mix,
+    tokenEstimate: payload.token_estimate,
+    elapsedMs: payload.elapsed_ms,
+    harness: payload.harness,
+  });
+}
+
+async function recordMemoryRecallEvent(projectRoot, observation = {}, options = {}) {
+  return recordMemoryRecallPayload(projectRoot, buildRecallEventPayload(observation), options);
+}
+
+async function recordMemoryRecallPayload(projectRoot, payload, options = {}) {
+  let store = options.store;
+  let ownsStore = false;
+  try {
+    const safePayload = normalizeRecallEventPayload(payload);
+    const projectId = options.projectId || projectMemory.resolveProjectId(projectRoot, options);
+    if (!store) {
+      store = createBuiltinSQLiteDriver({
+        databasePath: resolveKernelDatabasePath({
+          projectRoot,
+          gitCommonDir: options.gitCommonDir,
+          databasePath: options.databasePath,
+        }),
+      });
+      ownsStore = true;
+    }
+    const id = (options.randomUUID || randomUUID)();
+    const createdAt = options.now || new Date().toISOString();
+    await store.insertKernelEvent({
+      id,
+      entity_type: 'project',
+      entity_id: projectId,
+      event_type: EVENT_TYPE,
+      idempotency_key: id,
+      expected_revision: 0,
+      actor: 'forge',
+      origin: 'hook',
+      payload: safePayload,
+      created_at: createdAt,
+    });
+    return { recorded: true, eventId: id };
+  } catch (error) {
+    return {
+      recorded: false,
+      reason: error && error.message ? error.message : 'telemetry unavailable',
+    };
+  } finally {
+    if (ownsStore && store && typeof store.close === 'function') {
+      try {
+        store.close();
+      } catch {
+        // Best-effort evidence must never block recall.
+      }
+    }
+  }
+}
+
+function launchMemoryRecallEvent(projectRoot, observation = {}, options = {}) {
+  try {
+    const child = (options.spawn || spawn)(
+      process.execPath,
+      ['-e', EVENT_WRITER, __filename, projectRoot, JSON.stringify(buildRecallEventPayload(observation))],
+      { detached: true, stdio: 'ignore', windowsHide: true },
+    );
+    if (child && typeof child.on === 'function') child.on('error', () => {});
+    if (child && typeof child.unref === 'function') child.unref();
+    return { launched: true };
+  } catch {
+    return { launched: false };
+  }
+}
+
+module.exports = {
+  EVENT_TYPE,
+  buildRecallEventPayload,
+  launchMemoryRecallEvent,
+  recordMemoryRecallEvent,
+  recordMemoryRecallPayload,
+};

package/lib/memory-recall.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { fenceUntrusted } = require('./untrusted-content');
+
 /**
  * @module memory-recall
  *
@@ -50,6 +52,50 @@ function estimateTokens(text) {
   return Math.ceil(String(text || '').length / 4);
 }
 
+function normalizeMemoryType(entry) {
+  const tags = Array.isArray(entry?.tags) ? entry.tags : [];
+  const tagged = tags.find(tag => /^type:[a-z0-9][a-z0-9-]{0,63}$/i.test(tag));
+  if (tagged) return tagged.slice('type:'.length).toLowerCase();
+  const category = entry?.value && typeof entry.value === 'object'
+    ? entry.value.category
+    : null;
+  if (typeof category === 'string' && /^[a-z0-9][a-z0-9-]{0,63}$/i.test(category)) {
+    return category.toLowerCase();
+  }
+  return entry?.value && typeof entry.value === 'object' ? 'machine-record' : 'note';
+}
+
+function memoryTrustStatus(entry) {
+  const tags = Array.isArray(entry?.tags) ? entry.tags : [];
+  const normalizedTags = tags.map(tag => String(tag).toLowerCase());
+  if (normalizedTags.includes('trust:confirmed')) return 'confirmed';
+  if (normalizedTags.some(tag => tag.startsWith('trust:')
+    || tag === 'forge:auto-capture')) return 'suggested';
+  if (entry?.sourceAgent === 'forge remember (imported)') return 'suggested';
+  if (entry?.value && typeof entry.value === 'object') return 'suggested';
+  if (entry?.sourceAgent === 'forge remember' && typeof entry.value === 'string') return 'confirmed';
+  return 'suggested';
+}
+
+function normalizeRecallHit(entry, projectId) {
+  if (!entry) return null;
+  if (entry.memory_id) return entry;
+  const sourceRefs = Array.isArray(entry.beadsRefs) ? entry.beadsRefs : [];
+  return {
+    memory_id: entry.key,
+    type: normalizeMemoryType(entry),
+    content: typeof entry.value === 'string' ? entry.value : JSON.stringify(entry.value),
+    scope: !entry.scope || entry.scope === 'project' ? projectId : entry.scope,
+    trust_status: memoryTrustStatus(entry),
+    provenance: {
+      source_agent: entry.sourceAgent || '',
+      source_refs: sourceRefs,
+    },
+    updated_at: entry.timestamp,
+    score: entry.score,
+  };
+}
+
 /**
  * Parse the JSON payload Claude Code delivers on a UserPromptSubmit hook's stdin. Never
  * throws — any malformed input yields an empty prompt so the hook fails open.
@@ -99,7 +145,7 @@ function meaningfulTokens(query) {
  *
  * @param {object} args
  * @param {string} args.query — the submitted prompt
- * @param {Array<{key:string, value:string, score:number}>} args.hits — bm25-ordered
+ * @param {Array<{memory_id:string, content:string, score:number}>} args.hits — bm25-ordered
  *   (best/lowest score first), already relevance-only (token-AND matched)
  * @param {number} [args.scoreFloor] — keep only hits with score <= floor (more negative =
  *   stronger). Omit/null to rely on the FTS match alone. The VALUE is corpus-dependent and
@@ -116,28 +162,40 @@ function selectInjection({ query, hits, scoreFloor = null, tokenBudget = DEFAULT
 
   const exclude = new Set(excludeKeys || []);
   const lines = [];
+  const entries = [];
   const injectedKeys = [];
+  const usedSections = new Set();
   let spent = 0;
 
   for (const hit of hits || []) {
-    if (!hit || typeof hit.key !== 'string') continue;
-    if (exclude.has(hit.key)) continue;
+    const memoryId = hit?.memory_id ?? hit?.key;
+    if (typeof memoryId !== 'string') continue;
+    if (exclude.has(memoryId)) continue;
     // Relevance floor: below the bar contributes nothing. bm25 is more-negative-is-better.
     if (typeof scoreFloor === 'number' && !(typeof hit.score === 'number' && hit.score <= scoreFloor)) {
       continue;
     }
-    const body = String(hit.value == null ? '' : hit.value);
-    const cost = estimateTokens(body);
+    const body = String((hit.content ?? hit.value) == null ? '' : (hit.content ?? hit.value));
+    const trust = hit.trust_status === 'confirmed' ? 'confirmed' : 'suggested';
+    const source = String(hit.provenance?.source_agent || hit.sourceAgent || 'unknown').slice(0, 80);
+    const updated = String(hit.updated_at || hit.timestamp || 'unknown').slice(0, 40);
+    const labeled = `[trust=${trust} source=${source} updated=${updated}] ${body}`;
+    const line = fenceUntrusted(labeled, { source: 'memory' });
+    const heading = trust === 'confirmed'
+      ? 'Confirmed memory (project-local; provenance shown)'
+      : 'Suggested memory — verify before relying';
+    const cost = estimateTokens(line) + (usedSections.has(trust) ? 0 : estimateTokens(`${heading}\n`));
     if (spent + cost > tokenBudget) {
-      // Budget exhausted; stop rather than skip-and-continue so the strongest fit.
-      break;
+      continue;
     }
-    lines.push(body);
-    injectedKeys.push(hit.key);
+    lines.push(line);
+    entries.push({ trust, line });
+    injectedKeys.push(memoryId);
+    usedSections.add(trust);
     spent += cost;
   }
 
-  return { lines, injectedKeys };
+  return { lines, entries, injectedKeys };
 }
 
 module.exports = {
@@ -145,6 +203,9 @@ module.exports = {
   DEFAULT_TOKEN_BUDGET,
   DEFAULT_SCORE_FLOOR,
   estimateTokens,
+  memoryTrustStatus,
+  normalizeMemoryType,
+  normalizeRecallHit,
   parseHookInput,
   meaningfulTokens,
   selectInjection,

package/lib/merge-rules.js

@@ -54,7 +54,7 @@
  * (squash | merge | rebase); and post-merge branch deletion.
  */
 
-const SUCCESS_CONCLUSIONS = new Set(['SUCCESS', 'NEUTRAL', 'SKIPPED', 'PASS', 'PASSED']);
+const SUCCESS_CONCLUSIONS = new Set(['SUCCESS']);
 const MS_PER_MIN = 60_000;
 
 /** Coerce an epoch-ms number, a Date, or an ISO string to epoch ms (NaN if unparseable). */
@@ -85,11 +85,15 @@ function toAccountList(arg) {
   return [String(arg).trim().toLowerCase()];
 }
 
-/** A CI check is green if its conclusion is a success-class conclusion. */
+/** A CI check is green only when it is terminal and explicitly successful. */
 function isCheckGreen(check) {
   if (!check || typeof check !== 'object') return false;
-  const conclusion = String(check.conclusion ?? check.state ?? check.status ?? '').toUpperCase();
-  return SUCCESS_CONCLUSIONS.has(conclusion);
+  if (Object.prototype.hasOwnProperty.call(check, 'state')
+    && !Object.prototype.hasOwnProperty.call(check, 'status')) {
+    return String(check.state || '').toUpperCase() === 'SUCCESS';
+  }
+  return String(check.status || '').toUpperCase() === 'COMPLETED'
+    && SUCCESS_CONCLUSIONS.has(String(check.conclusion || '').toUpperCase());
 }
 
 /** The most recent comment by timestamp; ties and unparseable stamps fall back to array order. */