@shadowforge0/aquifer-memory 1.9.0 → 1.9.1

package/core/memory-type-policy.js

@@ -0,0 +1,298 @@
+'use strict';
+
+const MEMORY_TYPE_POLICY = Object.freeze({
+  assistant_shaping: {
+    label: '回答塑形',
+    active: true,
+    defaultInheritance: 'defaultable',
+    defaultAspect: 'assistant_shaping',
+    bootstrapPriority: 0,
+    recallRank: 95,
+    runtimeContract: true,
+  },
+  constraint: {
+    label: '限制',
+    active: true,
+    defaultInheritance: 'additive',
+    defaultAspect: 'constraint',
+    bootstrapPriority: 1,
+    recallRank: 80,
+  },
+  state: {
+    label: '狀態',
+    active: true,
+    defaultInheritance: 'defaultable',
+    defaultAspect: 'state',
+    bootstrapPriority: 2,
+    recallRank: 60,
+  },
+  open_loop: {
+    label: '未完成',
+    active: true,
+    defaultInheritance: 'non_inheritable',
+    defaultAspect: 'open_loop',
+    bootstrapPriority: 3,
+    recallRank: 55,
+  },
+  decision: {
+    label: '決策',
+    active: true,
+    defaultInheritance: 'non_inheritable',
+    defaultAspect: 'decision',
+    bootstrapPriority: 4,
+    recallRank: 50,
+  },
+  preference: {
+    label: '偏好',
+    active: true,
+    defaultInheritance: 'defaultable',
+    defaultAspect: 'preference',
+    bootstrapPriority: 5,
+    recallRank: 70,
+  },
+  fact: {
+    label: '事實',
+    active: true,
+    defaultInheritance: 'defaultable',
+    defaultAspect: 'fact',
+    bootstrapPriority: 6,
+    recallRank: 40,
+  },
+  conclusion: {
+    label: '判斷',
+    active: true,
+    defaultInheritance: 'defaultable',
+    defaultAspect: 'conclusion',
+    bootstrapPriority: 7,
+    recallRank: 30,
+  },
+  entity_note: {
+    label: '註記',
+    active: true,
+    defaultInheritance: 'defaultable',
+    defaultAspect: 'entity_note',
+    bootstrapPriority: 8,
+    recallRank: 20,
+  },
+});
+
+const AUTHORITY_POLICY = Object.freeze({
+  raw_transcript: { strength: 0, sortPriority: 6 },
+  llm_inference: { strength: 1, sortPriority: 5 },
+  verified_summary: { strength: 2, sortPriority: 4 },
+  manual: { strength: 3, sortPriority: 2 },
+  system: { strength: 4, sortPriority: 3 },
+  executable_evidence: { strength: 5, sortPriority: 1 },
+  user_explicit: { strength: 6, sortPriority: 0 },
+});
+
+const FEEDBACK_WEIGHT = Object.freeze({
+  helpful: 0.15,
+  confirm: 0.10,
+  irrelevant: -0.20,
+  scope_mismatch: -0.25,
+  stale: -0.30,
+  incorrect: -0.50,
+});
+
+const ASSISTANT_SHAPING_KINDS = Object.freeze([
+  'response_style',
+  'interaction_boundary',
+  'retrieval_policy',
+  'tool_routing',
+  'memory_policy',
+  'user_preference',
+  'correction_pattern',
+  'decision_style',
+]);
+
+const ASSISTANT_SHAPING_SERVING_IMPACTS = Object.freeze([
+  'changes_future_responses',
+  'changes_retrieval_selection',
+  'changes_bootstrap_selection',
+  'changes_tool_routing',
+  'changes_memory_promotion',
+  'sets_user_boundary',
+  'sets_assistant_behavior',
+]);
+
+const ASSISTANT_SHAPING_PROMPT_LINES = Object.freeze([
+  'Use assistant_shaping only when a memory changes durable cross-consumer runtime behavior for the user: future response style, interaction boundary, retrieval selection, tool routing, or memory promotion policy.',
+  'Each assistant_shaping item must include guidance or policy text plus shapingKind, servingImpact, and userRelevance. For non-explicit-user-instruction summaries, include temporalSupport showing repeated observations, multiple sessions, or a consolidation window.',
+  'Treat shapingKind and servingImpact as extensible hints, not as a closed product taxonomy. If the item only reports current task state, implementation facts, or a single answer, keep it in the ordinary memory layer instead.',
+]);
+
+function normalizeToken(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function memoryTypePolicy(type) {
+  return MEMORY_TYPE_POLICY[normalizeToken(type)] || null;
+}
+
+function activeMemoryTypes() {
+  return Object.keys(MEMORY_TYPE_POLICY).filter(type => MEMORY_TYPE_POLICY[type].active);
+}
+
+function isActiveMemoryType(type) {
+  const policy = memoryTypePolicy(type);
+  return Boolean(policy && policy.active);
+}
+
+function defaultInheritanceForMemoryType(type) {
+  return memoryTypePolicy(type)?.defaultInheritance || 'defaultable';
+}
+
+function defaultAspectForMemoryType(type) {
+  return memoryTypePolicy(type)?.defaultAspect || normalizeToken(type) || 'memory';
+}
+
+function memoryTypeLabel(type) {
+  return memoryTypePolicy(type)?.label || '記憶';
+}
+
+function memoryTypeBootstrapPriority(type) {
+  return memoryTypePolicy(type)?.bootstrapPriority ?? 99;
+}
+
+function memoryTypeRecallRank(type) {
+  return memoryTypePolicy(type)?.recallRank ?? 0;
+}
+
+function memoryTypeRuntimeContract(type) {
+  return memoryTypePolicy(type)?.runtimeContract === true;
+}
+
+function authorityPolicy(authority) {
+  return AUTHORITY_POLICY[normalizeToken(authority)] || null;
+}
+
+function authorityStrength(authority) {
+  return authorityPolicy(authority)?.strength ?? 0;
+}
+
+function authoritySortPriority(authority) {
+  return authorityPolicy(authority)?.sortPriority ?? 99;
+}
+
+function feedbackWeight(type) {
+  return FEEDBACK_WEIGHT[normalizeToken(type)] || 0;
+}
+
+function sqlLiteral(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+function caseSql(expr, entries, valueKey, fallback) {
+  const clauses = entries
+    .map(([key, policy]) => `WHEN ${sqlLiteral(key)} THEN ${policy[valueKey]}`)
+    .join('\n    ');
+  return `CASE ${expr}\n    ${clauses}\n    ELSE ${fallback}\n  END`;
+}
+
+function memoryTypeBootstrapPrioritySql(expr = 'm.memory_type') {
+  return caseSql(expr, Object.entries(MEMORY_TYPE_POLICY), 'bootstrapPriority', 99);
+}
+
+function memoryTypeRecallRankSql(expr = 'm.memory_type') {
+  const entries = Object.entries(MEMORY_TYPE_POLICY)
+    .map(([key, policy]) => [key, { recallWeight: (policy.recallRank || 0) / 100 }]);
+  return caseSql(expr, entries, 'recallWeight', 0);
+}
+
+function authoritySortPrioritySql(expr = 'm.authority') {
+  return caseSql(expr, Object.entries(AUTHORITY_POLICY), 'sortPriority', 99);
+}
+
+function feedbackWeightSql(expr = 'f.feedback_type') {
+  const entries = Object.entries(FEEDBACK_WEIGHT).map(([key, weight]) => [key, { weight }]);
+  return caseSql(expr, entries, 'weight', 0);
+}
+
+function memoryTypeOf(record = {}) {
+  return record.memoryType || record.memory_type || record.type || 'memory';
+}
+
+function memorySummaryText(record = {}) {
+  return String(record.summary || record.summaryText || record.title || '').replace(/\s+/g, ' ').trim();
+}
+
+function assistantShapingMetadata(record = {}) {
+  const payload = record.payload && typeof record.payload === 'object' ? record.payload : {};
+  const entries = [
+    ['policy', payload.policyKey || payload.policy_key || record.policyKey || record.policy_key],
+    ['kind', payload.shapingKind || payload.shaping_kind || payload.kind || payload.category || record.shapingKind || record.shaping_kind],
+    ['impact', payload.servingImpact || payload.serving_impact || payload.impact || record.servingImpact || record.serving_impact],
+  ];
+  return entries
+    .map(([key, value]) => [key, String(value || '').trim()])
+    .filter(([, value]) => value);
+}
+
+function formatRuntimeMemoryLine(record = {}, opts = {}) {
+  const type = memoryTypeOf(record);
+  const label = opts.localizedLabel === true ? memoryTypeLabel(type) : type;
+  const attrs = [];
+  const scope = record.scopeKey || record.scope_key;
+  const authority = record.authority;
+  const confidence = record.confidence || record.payload?.confidence || record.payload?.currentMemoryConfidence;
+  if (opts.includeScope === true && scope) attrs.push(`scope=${scope}`);
+  if (opts.includeAuthority === true && authority) attrs.push(`authority=${authority}`);
+  if (opts.includeConfidence === true && confidence) attrs.push(`confidence=${confidence}`);
+  const suffix = attrs.length > 0 ? ` ${attrs.join(' ')}` : '';
+  const metadata = type === 'assistant_shaping'
+    ? assistantShapingMetadata(record).map(([key, value]) => `${key}=${value}`).join(' ')
+    : '';
+  const metadataSuffix = metadata ? ` (${metadata})` : '';
+  return `- ${label}${suffix}: ${memorySummaryText(record)}${metadataSuffix}`;
+}
+
+function assistantShapingKindAllowed(value) {
+  return ASSISTANT_SHAPING_KINDS.includes(normalizeToken(value));
+}
+
+function assistantShapingServingImpactAllowed(value) {
+  const token = normalizeToken(value);
+  return assistantShapingServingImpactKnown(token)
+    || /^(changes|sets|routes|selects|filters|prioritizes|suppresses)_[a-z0-9_]+$/.test(token);
+}
+
+function assistantShapingServingImpactKnown(value) {
+  return ASSISTANT_SHAPING_SERVING_IMPACTS.includes(normalizeToken(value));
+}
+
+function assistantShapingPromptLines() {
+  return ASSISTANT_SHAPING_PROMPT_LINES.slice();
+}
+
+module.exports = {
+  ASSISTANT_SHAPING_KINDS,
+  ASSISTANT_SHAPING_SERVING_IMPACTS,
+  AUTHORITY_POLICY,
+  FEEDBACK_WEIGHT,
+  MEMORY_TYPE_POLICY,
+  activeMemoryTypes,
+  assistantShapingKindAllowed,
+  assistantShapingMetadata,
+  assistantShapingPromptLines,
+  assistantShapingServingImpactAllowed,
+  assistantShapingServingImpactKnown,
+  authoritySortPriority,
+  authoritySortPrioritySql,
+  authorityStrength,
+  defaultAspectForMemoryType,
+  defaultInheritanceForMemoryType,
+  feedbackWeight,
+  feedbackWeightSql,
+  formatRuntimeMemoryLine,
+  isActiveMemoryType,
+  memorySummaryText,
+  memoryTypeBootstrapPriority,
+  memoryTypeBootstrapPrioritySql,
+  memoryTypeLabel,
+  memoryTypeOf,
+  memoryTypePolicy,
+  memoryTypeRecallRank,
+  memoryTypeRecallRankSql,
+  memoryTypeRuntimeContract,
+};

package/core/postgres-migrations.js

@@ -93,6 +93,14 @@ const MIGRATION_PLAN = [
       { index: 'idx_feedback_memory_review_latest' },
     ],
   },
+  {
+    id: '020-v1-assistant-shaping-memory',
+    file: '020-v1-assistant-shaping-memory.sql',
+    always: true,
+    signature: [
+      { index: 'idx_memory_records_assistant_shaping_bootstrap' },
+    ],
+  },
 ];
 
 function createPostgresMigrationRuntime(opts = {}) {
@@ -309,6 +317,7 @@ function createPostgresMigrationRuntime(opts = {}) {
           ['017-v1-memory-record-embeddings.sql', '017-v1-memory-record-embeddings'],
           ['018-v1-finalization-candidate-envelope.sql', '018-v1-finalization-candidate-envelope'],
           ['019-v1-memory-review-resolutions.sql', '019-v1-memory-review-resolutions'],
+          ['020-v1-assistant-shaping-memory.sql', '020-v1-assistant-shaping-memory'],
         ]) {
           await client.query(loadSql(migration[0], schema));
           ddlExecuted.push(migration[1]);

package/core/session-checkpoint-producer.js

@@ -2,11 +2,12 @@
 
 const crypto = require('node:crypto');
 const { sanitizeSummaryResult } = require('./memory-safety-gate');
+const { assistantShapingPromptLines } = require('./memory-type-policy');
 const { buildScopeEnvelope, getScopeByEnvelopeId } = require('./scope-attribution');
 
 const DEFAULT_POLICY_VERSION = 'session_checkpoint_producer_v1';
 const DEFAULT_COVERAGE_COORDINATE_SYSTEM = 'codex_sanitized_view_v1';
-const STRUCTURED_SUMMARY_SHAPE = '{"summaryText":"...","structuredSummary":{"facts":[],"decisions":[],"open_loops":[],"preferences":[],"constraints":[],"conclusions":[],"entity_notes":[],"states":[]},"coverage":{"coordinateSystem":"codex_sanitized_view_v1","coveredUntilMessageIndex":0,"coveredUntilChar":0}}';
+const STRUCTURED_SUMMARY_SHAPE = '{"summaryText":"...","structuredSummary":{"assistant_shaping":[],"facts":[],"decisions":[],"open_loops":[],"preferences":[],"constraints":[],"conclusions":[],"entity_notes":[],"states":[]},"coverage":{"coordinateSystem":"codex_sanitized_view_v1","coveredUntilMessageIndex":0,"coveredUntilChar":0}}';
 
 function stableJson(value) {
   if (Array.isArray(value)) return `[${value.map(stableJson).join(',')}]`;
@@ -318,6 +319,7 @@ function buildCheckpointSynthesisPrompt(synthesisInput = {}, opts = {}) {
     'Return compact JSON with this shape:',
     STRUCTURED_SUMMARY_SHAPE,
     `Keep facts/decisions/open_loops concrete and scoped. Use at most ${maxFacts} facts.`,
+    ...assistantShapingPromptLines(),
     'Preserve the coverage object so handoff can skip only the already-covered transcript range.',
     '',
     '<checkpoint_synthesis_input>',

package/core/session-checkpoints.js

@@ -44,7 +44,7 @@ function parsePositiveInt(value, fallback = 10, max = 200) {
 function compactStructuredSummary(value = {}) {
   if (!value || typeof value !== 'object') return {};
   const out = {};
-  for (const key of ['facts', 'decisions', 'open_loops', 'openLoops', 'preferences', 'constraints', 'conclusions', 'entity_notes', 'entityNotes', 'states']) {
+  for (const key of ['assistant_shaping', 'assistant_shaping_memories', 'facts', 'decisions', 'open_loops', 'openLoops', 'preferences', 'constraints', 'conclusions', 'entity_notes', 'entityNotes', 'states']) {
     const rows = Array.isArray(value[key]) ? value[key] : [];
     if (rows.length > 0) out[key] = rows.slice(0, 8);
   }

package/core/session-finalization.js

@@ -3,7 +3,7 @@
 const crypto = require('crypto');
 const storage = require('./storage');
 const { createMemoryRecords } = require('./memory-records');
-const { createMemoryPromotion } = require('./memory-promotion');
+const { createMemoryPromotion, sanitizePromotionCandidate } = require('./memory-promotion');
 const { sanitizeSummaryResult } = require('./memory-safety-gate');
 const { buildFinalizationReview, buildSessionStartContext } = require('./finalization-review');
 const { buildFinalizationInspection } = require('./finalization-inspector');
@@ -397,7 +397,7 @@ function createSessionFinalization({
             authority: input.authority || 'verified_summary',
             evidenceRefs,
           });
-      const candidates = decorateCandidates(rawCandidates, input);
+      const candidates = decorateCandidates(rawCandidates.map(sanitizePromotionCandidate), input);
       const candidateEnvelope = buildCandidateEnvelope(input, candidates, {
         transcriptHash: base.transcriptHash,
       });

package/docs/getting-started.md

@@ -104,13 +104,26 @@ Run with `--dry-run --json` to verify the active package version, extension path
 | Plan curated compaction | `npx aquifer compact --cadence daily --period-start 2026-04-27T00:00:00Z --period-end 2026-04-28T00:00:00Z` |
 | Generate a timer synthesis prompt | `npx aquifer operator compaction daily --include-synthesis-prompt --json` |
 | Apply reviewed timer synthesis candidates | `npx aquifer operator compaction daily --synthesis-summary-file /tmp/timer-summary.json --apply --promote-candidates --json` |
-| Show stats | `npx aquifer stats` |
-| Enrich pending sessions | `npx aquifer backfill` |
+| Check memory readiness | `npx aquifer stats` |
+| Check saved-content preparation | `npx aquifer backlog --json` |
+| Prepare saved content | `npx aquifer backfill` |
 | Resolve a reviewed memory issue | `npx aquifer review resolve --memory-id 42 --resolution resolved --reason "verified current" --expected-latest-issue-feedback-id 9 --json` |
 
+`stats`, `backlog`, MCP `memory_stats`, and MCP `memory_pending` default to the
+same public status surface: `Aquifer status` or `Saved content status`, plus
+`Available`, `Attention`, and `Action` where relevant. Use CLI `--diagnostics`
+or MCP `diagnostics: true` when a host needs raw counters, buckets, guidance,
+or samples.
+
 Timer synthesis is an operator-reviewed candidate workflow. The prompt output
 and summary JSON do not become active curated memory unless the apply step is
-run with `--promote-candidates`.
+run with `--promote-candidates`. Daily/weekly/monthly aggregate proposals are
+source-rollup material for review and lineage only; normal promotion is blocked
+until a reviewed synthesis summary is attached. Reviewed synthesis items must
+also pass the temporal distillation standard: each item needs `mergeKey`,
+`scopeClass`, `durability`, `promotionTarget`, and `sourceCanonicalKeys` from
+the prompt's `sourceCurrentMemory`, and runtime state also needs `staleAfter`
+or `validTo`.
 
 The default public serving mode is `legacy`. To test scoped curated memory serving, set `AQUIFER_MEMORY_SERVING_MODE=curated` plus `AQUIFER_MEMORY_ACTIVE_SCOPE_KEY` or `AQUIFER_MEMORY_ACTIVE_SCOPE_PATH`. Rollback is config-only: set the serving mode back to `legacy` and restart the MCP/CLI process.
 

package/docs/setup.md

@@ -303,7 +303,14 @@ The summary file must match the normal structured summary shape, for example:
   "summaryText": "Reviewed timer synthesis.",
   "structuredSummary": {
     "states": [
-      { "state": "The reviewed state that should continue into current memory." }
+      {
+        "state": "The reviewed state that should continue into current memory.",
+        "mergeKey": "product-state:example",
+        "scopeClass": "product_memory",
+        "durability": "durable",
+        "promotionTarget": "project_current_memory",
+        "sourceCanonicalKeys": ["memory:canonical:key-from-prompt"]
+      }
     ],
     "decisions": [],
     "open_loops": []
@@ -311,9 +318,61 @@ The summary file must match the normal structured summary shape, for example:
 }
 ```
 
+Assistant behavior memory uses the same reviewed synthesis path, but the
+serving text must be behavior-level rather than project-specific wording:
+
+```json
+{
+  "summaryText": "Reviewed assistant behavior synthesis.",
+  "structuredSummary": {
+    "assistant_shaping": [
+      {
+        "guidance": "The user dislikes paying time and token cost for rediscovery. On continuation work, start from known state before broad exploration.",
+        "shapingKind": "tool_routing",
+        "servingImpact": "changes_tool_routing",
+        "userRelevance": "This reduces repeated context work and keeps collaboration moving.",
+        "temporalSupport": { "observationCount": 3 },
+        "abstraction": {
+          "languageLevel": "user_behavior",
+          "appliesBeyondSource": true,
+          "sourceBound": false,
+          "principle": "The user values avoiding repeated context work."
+        },
+        "mergeKey": "mk_hates_repeating_context_work",
+        "scopeClass": "assistant_behavior",
+        "durability": "durable",
+        "promotionTarget": "assistant_behavior_memory",
+        "sourceCanonicalKeys": ["memory:canonical:key-from-prompt"]
+      }
+    ]
+  }
+}
+```
+
 Without `--promote-candidates`, synthesis output is recorded as candidate
 ledger material only. The prompt and summary file are producer material; active
-curated memory still requires the explicit promotion gate.
+curated memory still requires the explicit promotion gate. The deterministic
+aggregate proposals from a daily/weekly/monthly dry-run are source-rollup
+review material, not active temporal memory; the normal product path blocks
+their promotion unless a reviewed synthesis summary is attached.
+
+Reviewed synthesis items must pass the temporal distillation standard before
+they become promotable candidates. Each item needs `mergeKey`, `scopeClass`,
+`durability`, `promotionTarget`, and `sourceCanonicalKeys` that point to
+canonical keys from the prompt's `sourceCurrentMemory`; runtime state also needs
+`staleAfter` or `validTo`. Workspace/operator policy, transient material,
+runtime state without expiry, duplicate merge keys, invalid or missing source
+lineage, and unsupported promotion targets are rejected before promotion.
+`assistant_behavior_memory` additionally requires generalized user-behavior
+abstraction metadata and normalizes serving text to the abstraction principle.
+Candidate payloads keep only compact lineage references; per-candidate source
+lineage stays on the candidate trace and in the compaction ledger for audit.
+
+Consumers that should inherit user-level assistant behavior together with a
+project scope should include the user scope in the active path, for example
+`AQUIFER_MEMORY_ACTIVE_SCOPE_PATH=global,user:user,project:aquifer` and matching
+`AQUIFER_MEMORY_ALLOWED_SCOPE_KEYS`. Applicable `assistant_shaping` records are
+pinned ahead of ordinary project current memory during bootstrap.
 
 ## Read-only governance diagnostics
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shadowforge0/aquifer-memory",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "PG-native long-term memory for AI agents. Turn-level embedding, hybrid RRF ranking, optional knowledge graph. MCP server, CLI, and library API.",
   "main": "index.js",
   "files": [
@@ -72,7 +72,7 @@
   "scripts": {
     "test": "node --test test/*.test.js",
     "test:integration": "node --test test/integration.test.js",
-    "test:release:package": "node --test test/package-surface.test.js test/mcp-manifest.test.js test/local-backend.test.js test/scope-attribution.test.js test/doctor.test.js test/finalization-inspector.test.js test/memory-explain.test.js test/memory-review.test.js test/operator-observability.test.js test/storage-finalization-status.test.js test/cli-parseargs.test.js test/v1-checkpoint-ledger-schema.test.js test/v1-finalization-envelope-schema.test.js test/v1-memory-review-resolutions-schema.test.js test/v1-evidence-items.test.js test/v1-curated-semantic-recall.test.js test/session-checkpoints.test.js test/session-checkpoint-producer.test.js test/session-checkpoint-planner.test.js test/storage-checkpoint-ranges.test.js test/v1-serving-cutover.test.js test/v1-current-memory-contract.test.js test/v1-scope-inheritance.golden.test.js test/v1-bootstrap-determinism.test.js test/consumer-codex.test.js test/codex-recovery-script.test.js test/codex-handoff.test.js",
+    "test:release:package": "node --test test/package-surface.test.js test/mcp-manifest.test.js test/local-backend.test.js test/scope-attribution.test.js test/doctor.test.js test/finalization-inspector.test.js test/memory-explain.test.js test/memory-review.test.js test/operator-observability.test.js test/storage-finalization-status.test.js test/cli-parseargs.test.js test/v1-checkpoint-ledger-schema.test.js test/v1-finalization-envelope-schema.test.js test/v1-memory-review-resolutions-schema.test.js test/v1-evidence-items.test.js test/v1-curated-semantic-recall.test.js test/session-checkpoints.test.js test/session-checkpoint-producer.test.js test/session-checkpoint-planner.test.js test/storage-checkpoint-ranges.test.js test/v1-serving-cutover.test.js test/v1-current-memory-contract.test.js test/v1-assistant-shaping-memory.test.js test/v1-assistant-shaping-review-explain.test.js test/v1-scope-inheritance.golden.test.js test/v1-bootstrap-determinism.test.js test/consumer-codex.test.js test/codex-recovery-script.test.js test/codex-handoff.test.js",
     "test:release:db": "node -e \"if (!process.env.AQUIFER_TEST_DB_URL) { console.error('AQUIFER_TEST_DB_URL is required for test:release:db'); process.exit(1); }\" && node --test --test-concurrency=1 test/v1-evidence-items.test.js test/memory-review.integration.test.js test/consumer-mcp.integration.test.js test/consumer-cli.integration.test.js test/codex-finalization-serving.integration.test.js",
     "lint": "eslint index.js core/*.js core/backends/*.js consumers/cli.js consumers/mcp.js consumers/claude-code.js consumers/codex.js consumers/codex-active-checkpoint.js consumers/codex-current-memory.js consumers/codex-handoff.js consumers/openclaw-install.js consumers/openclaw-plugin.js consumers/opencode.js consumers/shared/*.js consumers/default/*.js consumers/default/prompts/*.js consumers/openclaw-ext/*.js pipeline/*.js pipeline/consolidation/*.js scripts/*.js test/*.js",
     "hooks:install": "git config core.hooksPath .githooks"

package/schema/004-completion.sql

@@ -9,8 +9,8 @@
 --   * consumer_profiles table — consumer schema registry with composite primary key
 --     (tenant_id, consumer_id, version) for future multi-tenant safety
 --
--- All identifiers stay parameterised on ${schema} so P4 schema rename
--- (miranda → aquifer) is a one-line config change rather than a DDL rewrite.
+-- All identifiers stay parameterised on ${schema} so schema renames remain a
+-- config change rather than a DDL rewrite.
 
 -- Ensure pg_trgm available (used by existing migrations; re-declared for independent
 -- run safety).
@@ -141,8 +141,8 @@ CREATE TRIGGER trg_consumer_profiles_updated_at
   EXECUTE FUNCTION ${schema}.set_updated_at();
 
 -- timeline_events: append-only event log keyed by (tenant, agent, occurred_at).
--- category vocabulary is consumer-owned (focus/todo/mood/handoff/narrative/cli
--- for Miranda default), event shape is strict core. idempotency_key UNIQUE
+-- category vocabulary is consumer-owned, event shape is strict core.
+-- idempotency_key UNIQUE
 -- across the table to make caller-driven dedupe safe.
 CREATE TABLE IF NOT EXISTS ${schema}.timeline_events (
   id                          BIGSERIAL    PRIMARY KEY,

package/schema/010-v1-finalization-review.sql

@@ -43,6 +43,78 @@ ALTER TABLE ${schema}.fact_assertions_v1
     'tombstoned','quarantined','archived','incorrect'
   ));
 
+ALTER TABLE ${schema}.memory_records
+  DROP CONSTRAINT IF EXISTS memory_records_lifecycle_consistency_check;
+
+ALTER TABLE ${schema}.memory_records
+  ADD CONSTRAINT memory_records_lifecycle_consistency_check
+  CHECK (
+    (valid_to IS NULL OR valid_from IS NULL OR valid_to > valid_from)
+    AND (revoked_at IS NULL OR accepted_at IS NULL OR revoked_at >= accepted_at)
+    AND (superseded_at IS NULL OR accepted_at IS NULL OR superseded_at >= accepted_at)
+    AND NOT (revoked_at IS NOT NULL AND superseded_at IS NOT NULL)
+    AND (status <> 'active' OR (
+      revoked_at IS NULL
+      AND superseded_at IS NULL
+      AND superseded_by IS NULL
+    ))
+    AND (status <> 'superseded' OR superseded_at IS NOT NULL)
+    AND (status <> 'revoked' OR revoked_at IS NOT NULL)
+  ) NOT VALID;
+
+ALTER TABLE ${schema}.fact_assertions_v1
+  DROP CONSTRAINT IF EXISTS fact_assertions_v1_lifecycle_consistency_check;
+
+ALTER TABLE ${schema}.fact_assertions_v1
+  ADD CONSTRAINT fact_assertions_v1_lifecycle_consistency_check
+  CHECK (
+    (valid_to IS NULL OR valid_from IS NULL OR valid_to > valid_from)
+    AND (revoked_at IS NULL OR accepted_at IS NULL OR revoked_at >= accepted_at)
+    AND (superseded_at IS NULL OR accepted_at IS NULL OR superseded_at >= accepted_at)
+    AND NOT (revoked_at IS NOT NULL AND superseded_at IS NOT NULL)
+    AND (status <> 'active' OR (
+      revoked_at IS NULL
+      AND superseded_at IS NULL
+      AND superseded_by IS NULL
+    ))
+    AND (status <> 'superseded' OR superseded_at IS NOT NULL)
+    AND (status <> 'revoked' OR revoked_at IS NOT NULL)
+  ) NOT VALID;
+
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1
+      FROM pg_constraint
+     WHERE conrelid = '${schema}.memory_records'::regclass
+       AND conname = 'memory_records_superseded_by_tenant_fk'
+  ) THEN
+    ALTER TABLE ${schema}.memory_records
+      ADD CONSTRAINT memory_records_superseded_by_tenant_fk
+      FOREIGN KEY (tenant_id, superseded_by)
+      REFERENCES ${schema}.memory_records (tenant_id, id)
+      NOT VALID;
+  END IF;
+END;
+$$;
+
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1
+      FROM pg_constraint
+     WHERE conrelid = '${schema}.fact_assertions_v1'::regclass
+       AND conname = 'fact_assertions_v1_superseded_by_tenant_fk'
+  ) THEN
+    ALTER TABLE ${schema}.fact_assertions_v1
+      ADD CONSTRAINT fact_assertions_v1_superseded_by_tenant_fk
+      FOREIGN KEY (tenant_id, superseded_by)
+      REFERENCES ${schema}.fact_assertions_v1 (tenant_id, id)
+      NOT VALID;
+  END IF;
+END;
+$$;
+
 -- =========================================================================
 -- Row-level finalization lineage
 -- =========================================================================

package/schema/020-v1-assistant-shaping-memory.sql

@@ -0,0 +1,30 @@
+-- Aquifer v1 assistant-shaping memory layer
+-- Requires: 007-v1-foundation.sql
+-- Usage: replace ${schema} with actual schema name
+--
+-- Adds a product-level memory type for user-facing assistant shaping:
+-- response style, retrieval policy, interaction boundaries, and tool routing.
+-- This remains curated memory, not a host/persona-specific schema concept.
+
+ALTER TABLE ${schema}.memory_records
+  DROP CONSTRAINT IF EXISTS memory_records_memory_type_check;
+
+ALTER TABLE ${schema}.memory_records
+  ADD CONSTRAINT memory_records_memory_type_check
+  CHECK (memory_type IN (
+    'assistant_shaping',
+    'fact','state','decision','preference','constraint',
+    'entity_note','open_loop','conclusion'
+  ));
+
+CREATE INDEX IF NOT EXISTS idx_memory_records_assistant_shaping_bootstrap
+  ON ${schema}.memory_records (tenant_id, scope_id, status, accepted_at DESC, id)
+  WHERE status = 'active'
+    AND memory_type = 'assistant_shaping'
+    AND visible_in_bootstrap;
+
+COMMENT ON CONSTRAINT memory_records_memory_type_check ON ${schema}.memory_records IS
+  'Allowed curated memory types. assistant_shaping stores user-facing assistant behavior and retrieval policy, not host-specific persona code.';
+
+COMMENT ON INDEX ${schema}.idx_memory_records_assistant_shaping_bootstrap IS
+  'Fast path for high-priority assistant-shaping memories during bootstrap materialization.';

package/scripts/backfill-canonical-key.js

@@ -32,7 +32,7 @@ function printUsageAndExit(code = 0) {
     'Usage: node scripts/backfill-canonical-key.js --schema <name> [options]',
     '',
     'Required:',
-    '  --schema <name>        Target schema (e.g. miranda, jenny)',
+    '  --schema <name>        Target schema (e.g. aquifer, app_memory)',
     '  --agent <id>           Limit to one agent (or use --all-agents)',
     '',
     'Optional:',

package/scripts/diagnose-fts-zh.js

@@ -27,7 +27,7 @@ const SCHEMA = process.env.AQUIFER_SCHEMA || 'public';
 
 const DEFAULT_QUERIES = [
   // latin
-  'afterburn', 'bootstrap', 'session', 'recall', 'entity', 'OpenCode', 'Jenny', 'Aquifer',
+  'afterburn', 'bootstrap', 'session', 'recall', 'entity', 'OpenCode', 'ExampleUser', 'Aquifer',
   // CJK short tokens — 最容易暴露 tokenizer 問題
   '記憶', '時區', '去重', '架構', '修復',
   // CJK phrase