The pattern write-back pushed a style note into its "saved" list even when the memory store answered 'unchanged', so the chat route announced "Auto-saved 1 memory" on every repeat of the same style signal. The legacy code checked for the note before writing; the contract port lost that. A style note that already exists is now neither written nor reported. Other write-back saves keep reporting repeats, as before the port. Not logged in upstream-fixes.md: the defect came with the P1.5 port and does not exist in the commercial product.
352 lines
16 KiB
TypeScript
352 lines
16 KiB
TypeScript
/**
|
|
* Pattern-based memory write-back. Inspects (userMsg, assistantMsg) for
|
|
* preference / decision / correction / structured-finding signals and writes
|
|
* the distilled memories into personal or workspace memory.
|
|
*
|
|
* Extracted from Orchestrator.autoSaveFromExchange (PR-A, 2026-05-27).
|
|
* Behavior preserved verbatim; only the call surface moved.
|
|
*
|
|
* Why this isn't in Orchestrator: pure transform of (userMsg, assistantMsg)
|
|
* against a fixed store-set; not bound to Orchestrator's identity / awareness
|
|
* / search / knowledge layers. Lifting it keeps Orchestrator a facade and
|
|
* lets the pattern set evolve (toward LLM-based extraction in PR-H) without
|
|
* churning the orchestrator surface.
|
|
*
|
|
* SOTA target: this is the regex-based predecessor of an LLM-driven memory
|
|
* writer (PR-H). The patterns here are deliberately conservative — false-
|
|
* positive suppression matters more than recall, because every saved memory
|
|
* becomes recallable context.
|
|
*/
|
|
|
|
import {
|
|
PERSONAL_SCOPE,
|
|
workspaceScope,
|
|
type MemoryImportance,
|
|
type MemoryKind,
|
|
type MemoryRecord,
|
|
type MemorySource,
|
|
type MemoryStore,
|
|
} from '@waggle/memory-contract';
|
|
import { createCoreLogger, evaluateExternalMemoryIngress } from '@waggle/core';
|
|
import { isSelfIncapacityAssertion } from './memory-sign-gate.js';
|
|
import {
|
|
MIN_CONTENT_LENGTH,
|
|
DEDUP_SLICE_LENGTH,
|
|
RECALL_LINE_LENGTH,
|
|
FINDINGS_SLICE_LENGTH,
|
|
STRUCTURED_EXTRACT_THRESHOLD,
|
|
CONTEXT_PREVIEW_LENGTH,
|
|
} from './content-constants.js';
|
|
|
|
const logger = createCoreLogger('pattern-write-back');
|
|
|
|
/**
|
|
* Where the extractor writes. Preferences, corrections and style notes go to
|
|
* personal memory; decisions and work output go to the active workspace, or
|
|
* to personal memory when no workspace is active.
|
|
*/
|
|
export interface PatternWriteBackDeps {
|
|
memory: MemoryStore;
|
|
/** Active workspace, or null for personal-only mode. */
|
|
workspaceId: string | null;
|
|
}
|
|
|
|
// ── Pattern definitions (lifted from inline orchestrator function) ──
|
|
|
|
const CASUAL_PATTERNS: readonly RegExp[] = [
|
|
/\b(lunch|dinner|breakfast|coffee|pizza|food|snack|drink)\b/i,
|
|
/\b(weather|weekend|holiday|vacation|birthday|party)\b/i,
|
|
/^(hi|hey|hello|thanks|thank you|bye|goodbye)\b/i,
|
|
// Bare acks — only when the entire user message is just that word
|
|
/^(ok|okay|sure|yep|nope|yes|no)[.!?\s]*$/i,
|
|
];
|
|
|
|
const PREFERENCE_PATTERNS: readonly RegExp[] = [
|
|
/\bi (?:prefer|like|want|need|always|never)\b/i,
|
|
/\bcall me\b/i,
|
|
/\bmy (?:name|style|preference)\b/i,
|
|
/\bdon'?t (?:ever|always)\b/i,
|
|
/\bi(?:'d| would) rather\b/i,
|
|
/\bkeep (?:it|things) (?:short|brief|concise|detailed)\b/i,
|
|
/\buse (?:bullet|numbered|markdown|plain)\b/i,
|
|
/\bstop (?:doing|saying|adding)\b/i,
|
|
/\bfrom now on\b/i,
|
|
/\bplease (?:always|never|don'?t)\b/i,
|
|
];
|
|
|
|
const STYLE_SIGNALS: ReadonlyArray<{ pattern: RegExp; note: string }> = [
|
|
{ pattern: /\b(?:bullet|bullets|bullet.?points?|list form)\b/i, note: 'Style note: User prefers bullet-point format' },
|
|
{ pattern: /\b(?:keep it (?:short|brief)|tl;?dr|tldr|short version|in brief)\b/i, note: 'Style note: User prefers concise responses' },
|
|
{ pattern: /\b(?:explain|detail|elaborate|go deeper|more detail|thorough)\b/i, note: 'Style note: User prefers detailed explanations' },
|
|
{ pattern: /\b(?:table|tabular|spreadsheet|columns)\b/i, note: 'Style note: User prefers tabular data presentation' },
|
|
{ pattern: /\b(?:code first|show me the code|just the code)\b/i, note: 'Style note: User prefers code examples over prose' },
|
|
{ pattern: /\b(?:plain english|simple terms|eli5|layman|non.?technical)\b/i, note: 'Style note: User prefers non-technical language' },
|
|
];
|
|
|
|
const DECISION_PATTERNS: readonly RegExp[] = [
|
|
/\b(?:let'?s go with|we(?:'ll| will) (?:use|go with|do)|decided to|decision:|agreed to)\b/i,
|
|
/\bthe plan is\b/i,
|
|
/\bok(?:ay)?,?\s+(?:option|choice|approach)\s*(?:[a-z]|\d)/i,
|
|
/\blet'?s (?:proceed|move forward|do that|go ahead)\b/i,
|
|
/\bwe(?:'re| are) going (?:with|to)\b/i,
|
|
/\bfinal(?:ly|ized)?\s+(?:decision|choice|answer)\b/i,
|
|
/\bi(?:'ll| will) go (?:with|ahead)\b/i,
|
|
];
|
|
|
|
// Anchored start, length-gated to avoid matching long hedged replies that
|
|
// happen to begin with "yes but …". Used both as the early "looks-like-
|
|
// acceptance" gate and the explicit bilateral-consent check below.
|
|
const ACCEPTANCE_REGEX = /^(?:ok(?:ay)?|yes|yeah|yep|sure|go|go ahead|do it|let'?s (?:do (?:it|that)|proceed|go)|sounds good|perfect|great|that works|go with (?:it|that))\b/i;
|
|
|
|
const CORRECTION_PATTERNS: readonly RegExp[] = [
|
|
/\b(?:no,? (?:actually|that'?s wrong|it'?s)|wrong|incorrect|not (?:right|correct|true)|you'?re mistaken)\b/i,
|
|
];
|
|
|
|
const INLINE_DECISION_PATTERNS: readonly RegExp[] = [
|
|
/\b(?:recommended|recommend|suggestion is|best approach|should use|going with)\b/i,
|
|
/\b(?:conclusion|concluded|summary|in summary)\b/i,
|
|
];
|
|
|
|
// Assistant examples are instructional output, not evidence about the user.
|
|
// Suppress structured write-back for these responses; false positives are more
|
|
// damaging here than losing a temporary summary of an example-heavy answer.
|
|
const ILLUSTRATIVE_EXAMPLE_PATTERNS: readonly RegExp[] = [
|
|
/\bfor example\s*:/i,
|
|
/\be\.g\.\s*:/i,
|
|
/\bexamples?\s*:/i,
|
|
/\bhere (?:are|'s) (?:some|a few|an?) examples?\b/i,
|
|
];
|
|
|
|
type SaveTarget = 'workspace' | 'personal';
|
|
|
|
/**
|
|
* Post-response heuristic write-back. Scans (userMsg, assistantMsg) for
|
|
* save-worthy signals and writes distilled memories. Returns short
|
|
* previews of what was saved (DEDUP_SLICE_LENGTH chars each).
|
|
*
|
|
* Routing:
|
|
* target='workspace' → the active workspace's memory, else personal
|
|
* target='personal' → always personal (preferences, corrections, style)
|
|
*/
|
|
export async function runPatternWriteBack(
|
|
deps: PatternWriteBackDeps,
|
|
userMsg: string,
|
|
assistantMsg: string,
|
|
opts?: { traceId?: string; sessionId?: string },
|
|
): Promise<string[]> {
|
|
const saved: string[] = [];
|
|
|
|
// Helper: persist one memory, applying the ingress guard and the sign-gate
|
|
// downgrade. Returns the stored record (an identical earlier memory when the
|
|
// text already exists), or null when the guard refused it.
|
|
const save = async (
|
|
content: string,
|
|
importance: MemoryImportance,
|
|
kind: MemoryKind,
|
|
target: SaveTarget = 'workspace',
|
|
// PR3.5 honesty (review H-1): this is a heuristic EXTRACTOR, so its writes
|
|
// default to 'agent_inferred'. Genuinely user-authored memories
|
|
// (preferences, corrections) pass 'user_stated' explicitly.
|
|
source: MemorySource = 'agent_inferred',
|
|
// Style notes are written once; seeing the same signal again is not a save.
|
|
reportRepeat = true,
|
|
): Promise<MemoryRecord | null> => {
|
|
if (evaluateExternalMemoryIngress({ content }).action !== 'allow') return null;
|
|
|
|
// R2 sign gate (DEFECT-2): self-incapacity assertions persist at
|
|
// 'temporary' so they're audit-visible but cannot re-enter the prompt as
|
|
// authoritative recall (recall excludes 'temporary').
|
|
if (importance !== 'temporary' && isSelfIncapacityAssertion(content)) {
|
|
logger.debug('autoSave sign-gate: self-incapacity memory downgraded to temporary', {
|
|
preview: content.slice(0, DEDUP_SLICE_LENGTH),
|
|
});
|
|
importance = 'temporary';
|
|
}
|
|
const scope = target === 'workspace' && deps.workspaceId
|
|
? workspaceScope(deps.workspaceId)
|
|
: PERSONAL_SCOPE;
|
|
|
|
// PR3.5 memory↔trace backlink: the execution-trace id that produced this
|
|
// memory, so the "Why did you do that?" view can resolve the decision.
|
|
// An identical earlier memory keeps the trace that originally wrote it.
|
|
const [change] = await deps.memory.remember({
|
|
scope,
|
|
text: content,
|
|
kind,
|
|
importance,
|
|
source,
|
|
origin: 'chat-write-back',
|
|
...(opts?.sessionId && { sessionId: opts.sessionId }),
|
|
...(opts?.traceId && { metadata: { trace_id: opts.traceId } }),
|
|
});
|
|
if (reportRepeat || change?.event === 'added') {
|
|
saved.push(content.slice(0, DEDUP_SLICE_LENGTH));
|
|
}
|
|
return change?.record ?? null;
|
|
};
|
|
|
|
// ── Early gate: short messages skip unless they look like a decision ack ──
|
|
// Review #12: short acceptances ("ok, go ahead") DO carry a decision when
|
|
// paired with an assistant suggestion, so we let those through.
|
|
const userTrimmedEarly = userMsg.trim();
|
|
const looksLikeAcceptance = ACCEPTANCE_REGEX.test(userTrimmedEarly);
|
|
if (userMsg.length < MIN_CONTENT_LENGTH && !assistantMsg.includes('```') && !looksLikeAcceptance) {
|
|
logger.debug('autoSave: skipping short exchange', { len: userMsg.length });
|
|
return saved;
|
|
}
|
|
|
|
// ── Casual filter: drop greetings, food/weather chatter, bare acks ──
|
|
if (CASUAL_PATTERNS.some(p => p.test(userMsg))) return saved;
|
|
|
|
// ── Pattern: explicit user preference ──
|
|
for (const pat of PREFERENCE_PATTERNS) {
|
|
if (pat.test(userMsg)) {
|
|
const sentences = userMsg.split(/[.!?\n]+/).filter(s => pat.test(s));
|
|
if (sentences.length > 0) {
|
|
// User stated the preference directly → genuine 'user_stated' provenance.
|
|
await save(`User preference: ${sentences[0].trim()}`, 'normal', 'preference', 'personal', 'user_stated');
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ── Implicit style detection (only if no explicit preference fired) ──
|
|
if (saved.length === 0 && userMsg.length > MIN_CONTENT_LENGTH) {
|
|
for (const { pattern, note } of STYLE_SIGNALS) {
|
|
if (pattern.test(userMsg)) {
|
|
// The store does not write identical text twice in one scope, and a
|
|
// note that already exists is not reported as saved again.
|
|
await save(note, 'normal', 'preference', 'personal', 'agent_inferred', false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ── Pattern: decision (REQUIRES BILATERAL AGREEMENT, Review C2) ──
|
|
// User states the decision, OR assistant states it AND user explicitly
|
|
// accepts. Combined-string matching previously saved unaccepted assistant
|
|
// suggestions as 'important' and polluted catch-up recall durably.
|
|
const userHasDecision = DECISION_PATTERNS.some(p => p.test(userMsg));
|
|
const assistantHasDecision = DECISION_PATTERNS.some(p => p.test(assistantMsg));
|
|
const userTrimmed = userMsg.trim();
|
|
const userAcceptsAssistant = userTrimmed.length < 60 && ACCEPTANCE_REGEX.test(userTrimmed);
|
|
|
|
let decisionText: string | null = null;
|
|
if (userHasDecision) {
|
|
for (const pat of DECISION_PATTERNS) {
|
|
const sentences = userMsg.split(/[.!?\n]+/).filter(s => pat.test(s));
|
|
if (sentences.length > 0) {
|
|
decisionText = sentences[0].trim().slice(0, RECALL_LINE_LENGTH);
|
|
break;
|
|
}
|
|
}
|
|
} else if (assistantHasDecision && userAcceptsAssistant) {
|
|
for (const pat of DECISION_PATTERNS) {
|
|
const sentences = assistantMsg.split(/[.!?\n]+/).filter(s => pat.test(s));
|
|
if (sentences.length > 0) {
|
|
decisionText = sentences[0].trim().slice(0, RECALL_LINE_LENGTH);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (decisionText) {
|
|
await save(`Decision: ${decisionText}`, 'important', 'decision');
|
|
}
|
|
|
|
// ── Pattern: user correction ──
|
|
if (CORRECTION_PATTERNS.some(p => p.test(userMsg))) {
|
|
// User stated the correction directly → genuine 'user_stated' provenance.
|
|
await save(`Correction from user: ${userMsg.slice(0, CONTEXT_PREVIEW_LENGTH)}`, 'important', 'fact', 'personal', 'user_stated');
|
|
}
|
|
|
|
// ── Pattern: research output with external sources ──
|
|
const hasUrls = /https?:\/\/[^\s)]+/.test(assistantMsg);
|
|
const hasStructuredFindings = assistantMsg.length > 600 && (
|
|
(assistantMsg.includes('\n## ') && hasUrls) ||
|
|
(assistantMsg.match(/^\d+\./gm)?.length ?? 0) >= 3
|
|
);
|
|
if (hasStructuredFindings) {
|
|
const headings = assistantMsg.match(/^##?\s+.+$/gm)?.slice(0, 3) ?? [];
|
|
const urls = assistantMsg.match(/https?:\/\/[^\s)]+/g)?.slice(0, 3) ?? [];
|
|
const findingSummary = [
|
|
...headings.map(h => h.replace(/^#+\s+/, '')),
|
|
...(urls.length > 0 ? [`Sources: ${urls.join(', ')}`] : []),
|
|
].join('. ');
|
|
if (findingSummary.length > 20) {
|
|
await save(`Research findings: ${findingSummary.slice(0, FINDINGS_SLICE_LENGTH)}`, 'important', 'summary');
|
|
}
|
|
}
|
|
|
|
// ── Structured extraction from substantial assistant output ──
|
|
if (assistantMsg.length > 200) {
|
|
const lines = assistantMsg.split('\n').filter(l => l.trim().length > 5);
|
|
const hasIllustrativeExamples = ILLUSTRATIVE_EXAMPLE_PATTERNS.some((p) => p.test(assistantMsg));
|
|
let savedStructured = false;
|
|
|
|
// Inline decisions (different patterns than the explicit decision block above)
|
|
inlineDecision: for (const pat of INLINE_DECISION_PATTERNS) {
|
|
if (saved.length >= 5) break;
|
|
for (const decisionLine of lines) {
|
|
if (!pat.test(decisionLine)) continue;
|
|
const text = decisionLine.replace(/^[-*\d.#]+\s*/, '').trim();
|
|
if (text.length <= 20) continue;
|
|
// Confabulation-persistence guard: this is the AGENT's own assertion,
|
|
// not a user-stated fact. Persist it audit-visible but at 'temporary'
|
|
// so the recall path (which excludes 'temporary') can't re-surface a
|
|
// confabulated specific as authoritative memory on a later turn.
|
|
if ((await save(`Recommendation: ${text.slice(0, RECALL_LINE_LENGTH)}`, 'temporary', 'note')) !== null) {
|
|
savedStructured = true;
|
|
break inlineDecision;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Save user's original question/statement as a frame (if substantive)
|
|
if (userMsg.length >= MIN_CONTENT_LENGTH && userMsg.length <= STRUCTURED_EXTRACT_THRESHOLD && saved.length < 5) {
|
|
const alreadyCapturedUser = saved.some(s =>
|
|
s.startsWith('User preference:') || s.startsWith('Correction from user:') || s.startsWith('Decision:')
|
|
);
|
|
if (!alreadyCapturedUser) {
|
|
if ((await save(`User asked: ${userMsg.slice(0, RECALL_LINE_LENGTH)}`, 'temporary', 'note')) !== null) {
|
|
savedStructured = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Extract key facts from bullet points or numbered lists
|
|
if (assistantMsg.length > STRUCTURED_EXTRACT_THRESHOLD) {
|
|
const bullets = lines
|
|
.filter(l => l.match(/^[-*]\s/) || l.match(/^\d+\.\s/))
|
|
.map(l => l.replace(/^[-*\d.]+\s+/, '').trim())
|
|
.filter(l => l.length > 15 && l.length < 300);
|
|
|
|
if (bullets.length >= 2 && saved.length < 5 && !hasIllustrativeExamples) {
|
|
const keyPoints = bullets.slice(0, 3).join('; ');
|
|
const heading = lines.find(l => l.startsWith('#'))?.replace(/^#+\s+/, '') ?? '';
|
|
const prefix = heading ? `${heading}: ` : 'Key points: ';
|
|
// Agent-extracted bullets from its own reply — audit-visible but
|
|
// 'temporary' (recall-excluded) so confabulated specifics can't loop back.
|
|
if ((await save(`${prefix}${keyPoints.slice(0, FINDINGS_SLICE_LENGTH)}`, 'temporary', 'note')) !== null) {
|
|
savedStructured = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fallback: compact summary when nothing structured fired and the
|
|
// response is substantial. Never save the full blob — distill first.
|
|
if (!savedStructured && !hasIllustrativeExamples && assistantMsg.length > STRUCTURED_EXTRACT_THRESHOLD && saved.length === 0) {
|
|
const heading = lines.find(l => l.startsWith('#'))?.replace(/^#+\s+/, '') ?? '';
|
|
const firstMeaningful = lines.find(l => !l.startsWith('#') && l.length > 20)?.trim() ?? '';
|
|
const summary = heading
|
|
? `${heading}${firstMeaningful ? ': ' + firstMeaningful : ''}`
|
|
: firstMeaningful || 'Work output produced';
|
|
// Agent's own summary of its reply — audit-visible but 'temporary'
|
|
// (recall-excluded) to sever the confabulation→save→recall-as-fact loop.
|
|
await save(`Work completed: ${summary.slice(0, RECALL_LINE_LENGTH)}`, 'temporary', 'note');
|
|
}
|
|
}
|
|
|
|
return saved;
|
|
}
|