@try-works/dsh-memory 0.1.19 → 0.1.20

package/src/config.js

@@ -1,57 +1,57 @@
-// Schemastery Config schema. Only .volatile() fields are exposed to the Settings UI and
-// may be written by the config editor; every other field is config-file only.
-//
-// Keep the UI surface deliberately small: where the store lives, which model performs
-// memory writes, and the git origin. The cadence/budget knobs below are advanced tuning
-// (they have sane defaults) and belong in the profile patch, not in a settings page.
-//
-// gitToken is .role('secret') so it is redacted over the wire and never returned.
-import z from '@deepseek-ai/schemastery'
-import { DEFAULT_CONFIG, defaultMemoryRoot } from './defaults.js'
-
-export const Config = z.object({
-  // --- Settings -> Memory ---
-  memoryRoot: z.string().default(defaultMemoryRoot()).volatile(),
-    // Where the schedule plugin keeps its tasks. Overridable so a test (or an unusual DSH_HOME)
-    // can point somewhere else; the default resolves DSH_HOME exactly as the harness does.
-    schedulePath: z.string().default('').volatile(),
-  // A PREFERENCE, not a requirement: memory work walks a ladder of the models this
-  // deployment can actually route to, so an empty value still works and an unusable model
-  // is skipped rather than losing the memory.
-  summaryModel: z.string().default('').volatile(),
-  gitRemote: z.string().default('').volatile(),
-  gitBranch: z.string().default(DEFAULT_CONFIG.gitBranch).volatile(),
-
-  // --- config-file only: credentials + identity ---
-  gitToken: z.string().role('secret').default(''),
-  gitName: z.string().default(''),
-  gitEmail: z.string().default(''),
-
-  // --- config-file only: cadences ---
-  memoryReasoningEffort: z.string().default(DEFAULT_CONFIG.memoryReasoningEffort),
-  autoCaptureIntervalMs: z.number().default(DEFAULT_CONFIG.autoCaptureIntervalMs),
-  commitDebounceMs: z.number().default(DEFAULT_CONFIG.commitDebounceMs),
-  autoSyncIntervalMs: z.number().default(DEFAULT_CONFIG.autoSyncIntervalMs),
-  autoConsolidateIntervalMs: z.number().default(DEFAULT_CONFIG.autoConsolidateIntervalMs),
-  autoConsolidateMinPending: z.number().default(DEFAULT_CONFIG.autoConsolidateMinPending),
-  autoConsolidateBatchSize: z.number().default(DEFAULT_CONFIG.autoConsolidateBatchSize),
-  autoRefreshIntervalMs: z.number().default(DEFAULT_CONFIG.autoRefreshIntervalMs),
-  autoHistoryIntervalMs: z.number().default(DEFAULT_CONFIG.autoHistoryIntervalMs),
-  autoHistoryLimit: z.number().default(DEFAULT_CONFIG.autoHistoryLimit),
-  summaryMinSignalChars: z.number().default(DEFAULT_CONFIG.summaryMinSignalChars),
-  digestKeepCount: z.number().default(DEFAULT_CONFIG.digestKeepCount),
-  rerankSearch: z.boolean().default(DEFAULT_CONFIG.rerankSearch),
-  injectionMaxChars: z.number().default(DEFAULT_CONFIG.injectionMaxChars),
-  injectionRefreshMs: z.number().default(DEFAULT_CONFIG.injectionRefreshMs),
-
-  // --- config-file only: summarizer + consolidation budgets ---
-  digestMaxUserTurns: z.number().default(DEFAULT_CONFIG.digestMaxUserTurns),
-  digestMaxAssistantGists: z.number().default(DEFAULT_CONFIG.digestMaxAssistantGists),
-  digestMaxMessageChars: z.number().default(DEFAULT_CONFIG.digestMaxMessageChars),
-  digestMaxBytes: z.number().default(DEFAULT_CONFIG.digestMaxBytes),
-  summaryMaxBullets: z.number().default(DEFAULT_CONFIG.summaryMaxBullets),
-  consolidateMaxPromptBytes: z.number().default(DEFAULT_CONFIG.consolidateMaxPromptBytes),
-  consolidateMaxDigestBytes: z.number().default(DEFAULT_CONFIG.consolidateMaxDigestBytes),
-})
-
-export default Config
+// Schemastery Config schema. Only .volatile() fields are exposed to the Settings UI and
+// may be written by the config editor; every other field is config-file only.
+//
+// Keep the UI surface deliberately small: where the store lives, which model performs
+// memory writes, and the git origin. The cadence/budget knobs below are advanced tuning
+// (they have sane defaults) and belong in the profile patch, not in a settings page.
+//
+// gitToken is .role('secret') so it is redacted over the wire and never returned.
+import z from '@deepseek-ai/schemastery'
+import { DEFAULT_CONFIG, defaultMemoryRoot } from './defaults.js'
+
+export const Config = z.object({
+  // --- Settings -> Memory ---
+  memoryRoot: z.string().default(defaultMemoryRoot()).volatile(),
+    // Where the schedule plugin keeps its tasks. Overridable so a test (or an unusual DSH_HOME)
+    // can point somewhere else; the default resolves DSH_HOME exactly as the harness does.
+    schedulePath: z.string().default('').volatile(),
+  // A PREFERENCE, not a requirement: memory work walks a ladder of the models this
+  // deployment can actually route to, so an empty value still works and an unusable model
+  // is skipped rather than losing the memory.
+  summaryModel: z.string().default('').volatile(),
+  gitRemote: z.string().default('').volatile(),
+  gitBranch: z.string().default(DEFAULT_CONFIG.gitBranch).volatile(),
+
+  // --- config-file only: credentials + identity ---
+  gitToken: z.string().role('secret').default(''),
+  gitName: z.string().default(''),
+  gitEmail: z.string().default(''),
+
+  // --- config-file only: cadences ---
+  memoryReasoningEffort: z.string().default(DEFAULT_CONFIG.memoryReasoningEffort),
+  autoCaptureIntervalMs: z.number().default(DEFAULT_CONFIG.autoCaptureIntervalMs),
+  commitDebounceMs: z.number().default(DEFAULT_CONFIG.commitDebounceMs),
+  autoSyncIntervalMs: z.number().default(DEFAULT_CONFIG.autoSyncIntervalMs),
+  autoConsolidateIntervalMs: z.number().default(DEFAULT_CONFIG.autoConsolidateIntervalMs),
+  autoConsolidateMinPending: z.number().default(DEFAULT_CONFIG.autoConsolidateMinPending),
+  autoConsolidateBatchSize: z.number().default(DEFAULT_CONFIG.autoConsolidateBatchSize),
+  autoRefreshIntervalMs: z.number().default(DEFAULT_CONFIG.autoRefreshIntervalMs),
+  autoHistoryIntervalMs: z.number().default(DEFAULT_CONFIG.autoHistoryIntervalMs),
+  autoHistoryLimit: z.number().default(DEFAULT_CONFIG.autoHistoryLimit),
+  summaryMinSignalChars: z.number().default(DEFAULT_CONFIG.summaryMinSignalChars),
+  digestKeepCount: z.number().default(DEFAULT_CONFIG.digestKeepCount),
+  rerankSearch: z.boolean().default(DEFAULT_CONFIG.rerankSearch),
+  injectionMaxChars: z.number().default(DEFAULT_CONFIG.injectionMaxChars),
+  injectionRefreshMs: z.number().default(DEFAULT_CONFIG.injectionRefreshMs),
+
+  // --- config-file only: summarizer + consolidation budgets ---
+  digestMaxUserTurns: z.number().default(DEFAULT_CONFIG.digestMaxUserTurns),
+  digestMaxAssistantGists: z.number().default(DEFAULT_CONFIG.digestMaxAssistantGists),
+  digestMaxMessageChars: z.number().default(DEFAULT_CONFIG.digestMaxMessageChars),
+  digestMaxBytes: z.number().default(DEFAULT_CONFIG.digestMaxBytes),
+  summaryMaxBullets: z.number().default(DEFAULT_CONFIG.summaryMaxBullets),
+  consolidateMaxPromptBytes: z.number().default(DEFAULT_CONFIG.consolidateMaxPromptBytes),
+  consolidateMaxDigestBytes: z.number().default(DEFAULT_CONFIG.consolidateMaxDigestBytes),
+})
+
+export default Config

package/src/consolidate-run.js

@@ -1,132 +1,132 @@
-// Consolidation orchestration: pending digests -> prompt -> llm -> parse -> apply.
-import { BACKFILL_GUIDANCE, buildConsolidatePrompt, parseChangeSummary, applyConsolidation } from './consolidate.js'
-import { advance, fail, readQueue, REASONS, STATES, transition } from './queue.js'
-import { mkdirSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { pendingDigests, readDigestText } from './capture.js'
-import { clipBlock } from './summarize.js'
-import { readAssociations } from './workspace.js'
-
-export async function runConsolidation(store, {
-  llm, digests, indexHeads, guidance, batchSize = 3, maxPromptBytes = 65536, maxDigestBytes = 20000, maxAttempts = 3,
-} = {}) {
-  // Prefer digests that actually have something to consolidate: a header-only digest costs a
-  // batch slot and a share of the prompt budget while carrying nothing.
-  const all = digests ?? pendingDigests(store)
-  const withContent = []
-  const headerOnly = []
-  for (const item of all) {
-    const raw = readDigestText(store.root, item.id)
-    if (raw.includes('summary (')) withContent.push(item)
-    else headerOnly.push({ ...item, empty: true })
-  }
-  const pending = withContent.concat(headerOnly).slice(0, batchSize)
-  if (pending.length === 0) return { consolidated: 0, written: 0 }
-  // Bound the prompt: a digest is clipped to its own ceiling, and the whole payload
-  // to the prompt budget. Each digest carries its header plus the most recent bullets.
-  // Hand the model the RIGHT workspace key instead of letting it invent one from a path.
-  const associations = readAssociations(store.root)
-  const keyForCwd = (text) => {
-    const match = /^Cwd: (.+)$/m.exec(String(text ?? ''))
-    if (!match) return undefined
-    const cwd = match[1].trim()
-    const hit = Object.entries(associations).find(([, a]) => a.path === cwd)
-    return hit ? hit[0] : undefined
-  }
-  const included = []
-  const payload = []
-  let backfilled = false
-  let budget = maxPromptBytes
-  for (const item of pending) {
-    const full = readDigestText(store.root, item.id)
-    const text = clipBlock(full, Math.min(maxDigestBytes, budget))
-    if (text === '') continue
-    // A digest with no summary section is a HEADER ONLY: capture has not summarized it yet
-    // (or its summary failed). It is not empty of purpose, it is empty of content, and sending
-    // it wastes a batch slot while inviting the model to mark it done forever.
-    const empty = !full.includes('summary (')
-    // A backfilled digest carries material reconstructed from an old session rather than a live
-    // summary. If ANY digest in the batch came from a backfill, the pass takes the stricter bar,
-    // so a reconstruction never extracts more eagerly than live work does.
-    if (full.includes('summary (backfill)')) backfilled = true
-    payload.push({ title: item.id, text, workspace: keyForCwd(text) })
-    included.push({ ...item, empty })
-    budget -= text.length
-    if (budget <= 0) break
-  }
-  if (payload.length === 0) return { consolidated: 0, written: 0 }
-  const prompt = buildConsolidatePrompt({ digests: payload, indexHeads: indexHeads ?? [], guidance: guidance ?? (backfilled ? BACKFILL_GUIDANCE : undefined) })
-  const text = await llm(prompt)
-  // Always keep the last exchange: without it, a successful-but-empty pass is
-  // indistinguishable from a parse that silently matched nothing.
-  try {
-    mkdirSync(join(store.root, 'logs'), { recursive: true })
-    writeFileSync(join(store.root, 'logs', 'consolidate-last.txt'), '--- PROMPT ---\n' + prompt + '\n\n--- REPLY ---\n' + String(text == null ? '' : text) + '\n')
-  } catch {}
-  const summary = parseChangeSummary(text)
-  if (!summary) {
-    // Never discard an unparseable reply: it is the only evidence of what the model
-    // actually said, and silently returning parseFailed makes this undiagnosable.
-    let dump = null
-    try {
-      mkdirSync(join(store.root, 'logs'), { recursive: true })
-      dump = join(store.root, 'logs', 'consolidate-failed-' + Date.now() + '.txt')
-      writeFileSync(dump, '--- PROMPT ---\n' + prompt + '\n\n--- REPLY ---\n' + String(text == null ? '' : text) + '\n')
-    } catch {}
-    return { consolidated: 0, written: 0, parseFailed: true, ...(dump ? { dump } : {}) }
-  }
-  const written = applyConsolidation(store, summary, { fallbackSource: 'consolidate' })
-
-  const handled = new Set(summary.digests ?? [])
-  const now = new Date().toISOString()
-  const wrote = written.length > 0
-  let consolidated = 0
-  let needsReview = 0
-  for (const item of included) {
-    let entry = readQueue(store.root).get(item.id)
-    // Material can COME BACK: a digest is rebuilt from its session log, or capture fills one that
-    // was empty. Nothing else notices, because consolidation no longer writes the legacy map - so
-    // a candidate still marked orphaned would fail forever against a digest that is right there.
-    if (entry?.state === STATES.ORPHANED && !item.empty) {
-      advance(store.root, item.id, STATES.SUMMARIZED, { detail: { recovered: true } })
-      entry = readQueue(store.root).get(item.id)
-    }
-    const attempts = Number(entry?.detail?.consolidateAttempts ?? 0) + 1
-    const detail = { consolidateAttempts: attempts }
-    // A digest with no summary section carries NOTHING to consolidate, so it is not finished
-    // work - it simply has no work yet. Recording the attempt without moving the state is the
-    // honest outcome: capture may still fill the digest, and marking it done would be forever.
-    if (item.empty) {
-      if (entry) transition(store.root, item.id, entry.state, { detail })
-      continue
-    }
-    const attributed = handled.has(item.id)
-    // The stage is RUNNING, and the journal says so. Without this a failure would appear to come
-    // straight from a waiting state, describing something that never happened - and a failure is
-    // only legal from the stage that failed.
-    if (entry) advance(store.root, item.id, STATES.CONSOLIDATING, { detail })
-    if (attributed) {
-      // ADDED only when something was actually written. A handled digest that produced no
-      // entries is SKIPPED, which is a correct outcome and must not look like a failure.
-      if (wrote) advance(store.root, item.id, STATES.ADDED, { attempts: 0, detail })
-      else advance(store.root, item.id, STATES.SKIPPED, { reason: REASONS.NO_ENTRIES, attempts: 0, detail })
-      consolidated += 1
-    } else if (attempts >= maxAttempts) {
-      // Never silently dropped: the digest stops being retried but is flagged for review, and
-      // the state SAYS so rather than leaving a reader to infer it from a timestamp plus a flag.
-      fail(store.root, item.id, { reason: REASONS.ATTEMPTS, attempts, detail })
-      consolidated += 1
-      needsReview += 1
-    } else if (entry) {
-      // Not attributed and the budget is not spent: back to waiting, with the attempt recorded.
-      advance(store.root, item.id, STATES.SUMMARIZED, { detail })
-    }
-  }
-  return {
-    consolidated, written: written.length, promptBytes: prompt.length,
-    ...(written.failed && written.failed.length ? { writeFailed: written.failed.length } : {}),
-    retried: included.length - consolidated,
-    ...(needsReview > 0 ? { needsReview } : {}),
-    summary,
-  }
-}
+// Consolidation orchestration: pending digests -> prompt -> llm -> parse -> apply.
+import { BACKFILL_GUIDANCE, buildConsolidatePrompt, parseChangeSummary, applyConsolidation } from './consolidate.js'
+import { advance, fail, readQueue, REASONS, STATES, transition } from './queue.js'
+import { mkdirSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { pendingDigests, readDigestText } from './capture.js'
+import { clipBlock } from './summarize.js'
+import { readAssociations } from './workspace.js'
+
+export async function runConsolidation(store, {
+  llm, digests, indexHeads, guidance, batchSize = 3, maxPromptBytes = 65536, maxDigestBytes = 20000, maxAttempts = 3,
+} = {}) {
+  // Prefer digests that actually have something to consolidate: a header-only digest costs a
+  // batch slot and a share of the prompt budget while carrying nothing.
+  const all = digests ?? pendingDigests(store)
+  const withContent = []
+  const headerOnly = []
+  for (const item of all) {
+    const raw = readDigestText(store.root, item.id)
+    if (raw.includes('summary (')) withContent.push(item)
+    else headerOnly.push({ ...item, empty: true })
+  }
+  const pending = withContent.concat(headerOnly).slice(0, batchSize)
+  if (pending.length === 0) return { consolidated: 0, written: 0 }
+  // Bound the prompt: a digest is clipped to its own ceiling, and the whole payload
+  // to the prompt budget. Each digest carries its header plus the most recent bullets.
+  // Hand the model the RIGHT workspace key instead of letting it invent one from a path.
+  const associations = readAssociations(store.root)
+  const keyForCwd = (text) => {
+    const match = /^Cwd: (.+)$/m.exec(String(text ?? ''))
+    if (!match) return undefined
+    const cwd = match[1].trim()
+    const hit = Object.entries(associations).find(([, a]) => a.path === cwd)
+    return hit ? hit[0] : undefined
+  }
+  const included = []
+  const payload = []
+  let backfilled = false
+  let budget = maxPromptBytes
+  for (const item of pending) {
+    const full = readDigestText(store.root, item.id)
+    const text = clipBlock(full, Math.min(maxDigestBytes, budget))
+    if (text === '') continue
+    // A digest with no summary section is a HEADER ONLY: capture has not summarized it yet
+    // (or its summary failed). It is not empty of purpose, it is empty of content, and sending
+    // it wastes a batch slot while inviting the model to mark it done forever.
+    const empty = !full.includes('summary (')
+    // A backfilled digest carries material reconstructed from an old session rather than a live
+    // summary. If ANY digest in the batch came from a backfill, the pass takes the stricter bar,
+    // so a reconstruction never extracts more eagerly than live work does.
+    if (full.includes('summary (backfill)')) backfilled = true
+    payload.push({ title: item.id, text, workspace: keyForCwd(text) })
+    included.push({ ...item, empty })
+    budget -= text.length
+    if (budget <= 0) break
+  }
+  if (payload.length === 0) return { consolidated: 0, written: 0 }
+  const prompt = buildConsolidatePrompt({ digests: payload, indexHeads: indexHeads ?? [], guidance: guidance ?? (backfilled ? BACKFILL_GUIDANCE : undefined) })
+  const text = await llm(prompt)
+  // Always keep the last exchange: without it, a successful-but-empty pass is
+  // indistinguishable from a parse that silently matched nothing.
+  try {
+    mkdirSync(join(store.root, 'logs'), { recursive: true })
+    writeFileSync(join(store.root, 'logs', 'consolidate-last.txt'), '--- PROMPT ---\n' + prompt + '\n\n--- REPLY ---\n' + String(text == null ? '' : text) + '\n')
+  } catch {}
+  const summary = parseChangeSummary(text)
+  if (!summary) {
+    // Never discard an unparseable reply: it is the only evidence of what the model
+    // actually said, and silently returning parseFailed makes this undiagnosable.
+    let dump = null
+    try {
+      mkdirSync(join(store.root, 'logs'), { recursive: true })
+      dump = join(store.root, 'logs', 'consolidate-failed-' + Date.now() + '.txt')
+      writeFileSync(dump, '--- PROMPT ---\n' + prompt + '\n\n--- REPLY ---\n' + String(text == null ? '' : text) + '\n')
+    } catch {}
+    return { consolidated: 0, written: 0, parseFailed: true, ...(dump ? { dump } : {}) }
+  }
+  const written = applyConsolidation(store, summary, { fallbackSource: 'consolidate' })
+
+  const handled = new Set(summary.digests ?? [])
+  const now = new Date().toISOString()
+  const wrote = written.length > 0
+  let consolidated = 0
+  let needsReview = 0
+  for (const item of included) {
+    let entry = readQueue(store.root).get(item.id)
+    // Material can COME BACK: a digest is rebuilt from its session log, or capture fills one that
+    // was empty. Nothing else notices, because consolidation no longer writes the legacy map - so
+    // a candidate still marked orphaned would fail forever against a digest that is right there.
+    if (entry?.state === STATES.ORPHANED && !item.empty) {
+      advance(store.root, item.id, STATES.SUMMARIZED, { detail: { recovered: true } })
+      entry = readQueue(store.root).get(item.id)
+    }
+    const attempts = Number(entry?.detail?.consolidateAttempts ?? 0) + 1
+    const detail = { consolidateAttempts: attempts }
+    // A digest with no summary section carries NOTHING to consolidate, so it is not finished
+    // work - it simply has no work yet. Recording the attempt without moving the state is the
+    // honest outcome: capture may still fill the digest, and marking it done would be forever.
+    if (item.empty) {
+      if (entry) transition(store.root, item.id, entry.state, { detail })
+      continue
+    }
+    const attributed = handled.has(item.id)
+    // The stage is RUNNING, and the journal says so. Without this a failure would appear to come
+    // straight from a waiting state, describing something that never happened - and a failure is
+    // only legal from the stage that failed.
+    if (entry) advance(store.root, item.id, STATES.CONSOLIDATING, { detail })
+    if (attributed) {
+      // ADDED only when something was actually written. A handled digest that produced no
+      // entries is SKIPPED, which is a correct outcome and must not look like a failure.
+      if (wrote) advance(store.root, item.id, STATES.ADDED, { attempts: 0, detail })
+      else advance(store.root, item.id, STATES.SKIPPED, { reason: REASONS.NO_ENTRIES, attempts: 0, detail })
+      consolidated += 1
+    } else if (attempts >= maxAttempts) {
+      // Never silently dropped: the digest stops being retried but is flagged for review, and
+      // the state SAYS so rather than leaving a reader to infer it from a timestamp plus a flag.
+      fail(store.root, item.id, { reason: REASONS.ATTEMPTS, attempts, detail })
+      consolidated += 1
+      needsReview += 1
+    } else if (entry) {
+      // Not attributed and the budget is not spent: back to waiting, with the attempt recorded.
+      advance(store.root, item.id, STATES.SUMMARIZED, { detail })
+    }
+  }
+  return {
+    consolidated, written: written.length, promptBytes: prompt.length,
+    ...(written.failed && written.failed.length ? { writeFailed: written.failed.length } : {}),
+    retried: included.length - consolidated,
+    ...(needsReview > 0 ? { needsReview } : {}),
+    summary,
+  }
+}