memorix 1.2.3 → 1.2.4

package/docs/1.2.4-PERSISTENT-MEMORY-DELIVERY.md

@@ -0,0 +1,86 @@
+# 1.2.4 Persistent Memory Delivery
+
+**Status:** release-ready
+**Date:** 2026-07-26
+
+## Problem
+
+Memorix already has durable project memory, Code State, session summaries,
+knowledge, visibility policy, CLI, and MCP. The delivery path was uneven:
+
+- A fresh agent without a visible MCP tool could guess through many CLI commands
+  before finding the relevant state.
+- The normal task Workset deliberately avoided generic old-chat dumping, but it
+  also hid the small amount of prior work that matters when a user says
+  "continue" or "take over".
+- A new retrieval path must not bypass the session visibility fix shipped in
+  1.2.3.
+
+This release improves delivery, not storage. It does not create a handoff
+database, a transcript archive, or another default MCP tool.
+
+## Product Contract
+
+| Situation | Delivery |
+| --- | --- |
+| Start a new, unrelated task | A bounded task Workset. No automatic prior-session text. |
+| Continue or take over prior work | The same Workset plus a bounded prior-work projection. |
+| MCP is available | Use the existing `memorix_project_context` tool with the real task. |
+| MCP is unavailable | Make one CLI call: `memorix resume "<task>" --json` for continuation or `memorix context "<task>" --json` for a new task. |
+| Claude Code hook is installed | An explicit continuation prompt receives the same bounded prior-work Workset through the official `UserPromptSubmit` context channel, unless `memory.inject = "silent"`. |
+| Read-only assessment | The brief may be read, but Memorix does not persist a new observation unless the user explicitly asks to save one. |
+| Need a deliberate session handoff | Keep using the explicit session/handoff surfaces; this projection does not replace them. |
+
+Continuation detection is independent of the underlying task lens. For example,
+"continue fixing the authentication timeout" is still a `bugfix` task, with
+bugfix verification guidance, plus bounded prior-work evidence.
+
+## Delivery Model
+
+```text
+Canonical project identity
+  -> existing SQLite sessions + durable observations + visibility policy
+  -> Task Workset
+       -> normal task: current facts, code state, selected evidence
+       -> continuation: normal task + one session summary + <=3 durable anchors
+  -> existing MCP Project Context, direct CLI Context/Resume, or an eligible host hook
+```
+
+The projection is intentionally small and source-aware:
+
+- The latest meaningful completed session summary is eligible.
+- At most three durable decision/fix/discovery-style observations are eligible.
+- Project, team, and personal visibility is enforced with the caller's reader.
+- The `ContextReceipt` records selected or budget-withheld continuation items.
+- Current code remains the authority; historical material is a lead, not an
+  instruction.
+
+## Explicit Non-Goals
+
+- Do not inject arbitrary transcript history into every request.
+- Do not infer continuation from every mention of a past file or release.
+- Do not add a separate `handoff` store or duplicate session memory.
+- Do not add an eighth default MCP tool merely for CLI parity.
+- Do not make an unbound terminal see personal or team-scoped memory.
+
+## Acceptance Gates
+
+1. A normal new task has no `Resume from prior work` section.
+2. A continuation task has a bounded section and keeps its real task lens.
+3. `memorix resume` and `memorix_project_context` share the Workset contract.
+4. A foreign identity cannot receive personal continuation evidence.
+5. Generated guidance performs one precise CLI fallback instead of help/search
+   enumeration or inferring an empty memory store from project files.
+6. Compiled package smoke proves CLI positional parsing and stdio MCP output.
+7. Claude Code receives an explicit continuation through its official
+   `UserPromptSubmit.additionalContext` path; an unrelated prompt stays quiet.
+8. A fresh agent-style user path evaluates the installed package without
+   modifying the maintainer's real agent configuration.
+9. A fresh package installation whose optional native SQLite binary cannot load
+   still preserves the same `memorix.db` across separate CLI and hook processes
+   through the supported Node 22 SQLite fallback.
+10. A successful Autopilot brief preserves the exact continuation flag/path or
+    command needed to act, and does not trigger redundant memory retrieval by
+    default.
+11. A read-only continuation assessment neither replays already-delivered
+    durable evidence nor writes a new memory without an explicit user request.

package/docs/AGENT_OPERATOR_PLAYBOOK.md

@@ -38,7 +38,7 @@ For the 1.2 release line, the visible product shape is:
 - model lanes are separate: `[memory.llm]` for formation/rerank/summaries, `[embedding]` for semantic search, `[agent]` for the model memcode talks to while coding
 - legacy `memorix.yml`, `.env`, and `~/.memorix/config.json` are compatibility inputs, not the recommended setup path
 - generated agent rules treat `memorix_session_start` as optional unless explicit session semantics matter
-- `memorix_project_context` / `memorix context --task "..."` is the normal black-box entry for non-trivial coding work: it assembles a bounded task Workset instead of injecting a generic memory dump
+- `memorix_project_context` / `memorix context "..."` is the normal black-box entry for non-trivial coding work: it assembles a bounded task Workset instead of injecting a generic memory dump; `memorix resume "..."` is the explicit CLI continuation projection
 - Code State keeps local snapshots and freshness links; a healthy pre-existing local CodeGraph index can add a bounded semantic outline, but Memorix never initializes or synchronizes that external index itself
 - `memorix knowledge` is an explicit review path for source-backed Markdown knowledge and canonical workflows. Do not initialize a versioned workspace or apply a proposal unless the user asks for that managed artifact
 - integration surfaces are agent-specific: Claude Code, Codex, GitHub Copilot CLI, Antigravity, and Hermes receive plugin packages; OpenClaw receives a compatible bundle; Pi and Oh-my-Pi receive package entries; Gemini CLI receives an extension package; OpenCode receives a plugin file and skill; Cursor and other agents receive MCP/rules/hooks where supported
@@ -766,6 +766,18 @@ memorix doctor
 
 to inspect active runtime status.
 
+### 9. Does a fresh CLI install report a `better-sqlite3` binding error?
+
+On the supported Node 22 runtime, current Memorix releases automatically use
+Node's built-in SQLite with the same local `memorix.db` when the optional
+`better-sqlite3` native binary is unavailable. Upgrade the package and rerun
+the command; do not delete the data directory or create a replacement database.
+
+Node may print its own experimental SQLite warning on that fallback path. It is
+not a memory-loss condition. If Memorix instead reports that SQLite is
+unavailable, confirm the installed Node version satisfies the package engine
+and include the exact error when filing an issue.
+
 ---
 
 ## 11. What Not to Do

package/docs/API_REFERENCE.md

@@ -59,7 +59,7 @@ The current CLI namespaces are:
 Typical examples:
 
 ```bash
-memorix --cwd /path/to/repo context --task "continue auth bug"
+memorix --cwd /path/to/repo resume "continue auth bug"
 memorix identity join --agent-type codex --name codex-main
 memorix session start --agent codex-main --agent-type codex --join-team --use
 memorix memory search --query "release blocker"
@@ -96,6 +96,8 @@ memorix codegraph status
 memorix codegraph status --json
 memorix context
 memorix context --task "continue auth bug"
+memorix context "continue auth bug"
+memorix resume "continue auth bug"
 memorix context --task "prepare 1.1.7 release"
 memorix explain
 memorix codegraph context-pack --task "continue auth bug"
@@ -107,11 +109,11 @@ MCP:
 - `memorix_codegraph_status` returns provider/index counts for the current project.
 - `memorix_context_pack` builds a task-specific packet with reliable current memories, lower-trust unbound memories, current code facts, freshness warnings, suggested reads, and suggested verification.
 
-`memorix context` defaults to `--refresh auto`, so first use can seed Code State without a separate manual `memorix codegraph refresh`. Its brief puts live package/changelog/Git facts before memory hints and flags old `progress.txt` / dev-log notes as historical when they predate the latest changelog, so agents should treat current facts as the source of truth when files disagree. Task lenses keep the packet shaped to the work: bugfix briefs prefer failing tests and repros, release briefs prefer metadata/changelog/package checks, and onboarding briefs prefer docs and entry points while hiding unrelated suspect details. Use `--refresh never` for read-only inspection and `--refresh always` when you want to force a fresh scan.
+`memorix context` defaults to `--refresh auto`, so first use can seed Code State without a separate manual `memorix codegraph refresh`. Its brief puts live package/changelog/Git facts before memory hints and flags old `progress.txt` / dev-log notes as historical when they predate the latest changelog, so agents should treat current facts as the source of truth when files disagree. Task lenses keep the packet shaped to the work: bugfix briefs prefer failing tests and repros, release briefs prefer metadata/changelog/package checks, and onboarding briefs prefer docs and entry points while hiding unrelated suspect details. Continuation delivery is separate from the task lens: continuation language in `memorix_project_context` enables a bounded prior-work projection, and `memorix resume "..."` makes that choice explicit. It includes only the latest useful session summary and up to three readable durable memories; ordinary new tasks do not receive historical-session context. A completed MCP brief is the default retrieval boundary: search, detail, or Context Pack should expand it only for a named missing fact or an explicit request for deeper history. Use `--refresh never` for read-only inspection and `--refresh always` when you want to force a fresh scan.
 
 Project-specific generated, vendored, or cache paths can be excluded from Code State with `[codegraph].exclude_patterns` in `memorix.toml` or `~/.memorix/config.toml` (`codegraph.excludePatterns` in legacy YAML). User patterns extend the built-in excludes and are applied to indexing, Project Context suggested reads, and Context Pack suggested reads.
 
-SessionStart hooks keep the default minimal hint lightweight. When memory behavior is configured with `sessionInject=full`, Memorix injects the compact Memory Autopilot brief at session start instead of only listing recent text memories.
+SessionStart hooks keep the default minimal hint lightweight. When memory behavior is configured with `sessionInject=full`, Codex receives the compact Memory Autopilot brief at session start instead of only listing recent text memories. Claude Code delivers an explicit continuation through its official `UserPromptSubmit` context channel, so a user saying “continue” receives the bounded prior-work brief even under the default minimal setting. Set `memory.inject = "silent"` to disable automatic hook delivery.
 
 The intended loop for agents is: get the project brief when it helps, inspect the suggested current files, use stale or unbound memory only as a lead, store durable outcomes after the work changes the project, and resolve obsolete memories.
 
@@ -220,6 +222,10 @@ require a joined coordination identity; a personal record is readable only by
 its creator and explicitly named recipients. Supplying a `topicKey` never
 lets an agent overwrite a record outside its write scope.
 
+When the current Autopilot task is read-only or explicitly says not to modify
+files, `memorix_store` returns without writing. Use `overrideReadOnly: true`
+only when the user explicitly asks to preserve a record during that task.
+
 Example:
 
 ```json
@@ -252,6 +258,8 @@ Important inputs:
 - `since`
 - `until`
 - `maxTokens`
+- `purpose` when deliberately expanding beyond the current Autopilot brief
+- `force: true` only when the user explicitly asks to re-read a record already represented in that brief
 
 Typical uses:
 
@@ -281,6 +289,8 @@ Global example:
 
 Fetch full observation detail.
 
+After `memorix_project_context`, use `purpose` only for a named missing fact. Set `force: true` only when the user explicitly asks for the full underlying record already represented in the brief.
+
 Supports two modes:
 
 - `ids` for current-project observations

package/docs/dev-log/progress.txt

@@ -4,13 +4,54 @@
 > older notes when they conflict.
 
 ## Current State
-- Phase: 1.2.3 session-context visibility hotfix
-- Branch: `codex/1.2.3-session-visibility`
-- Last updated: 2026-07-25
-- Released baseline: `memorix@1.2.2`, tag `v1.2.2`, `origin/main` at
-  `2a7ebc7`.
-- Goal: close the agent-facing session-context visibility boundary before
-  further control-plane work.
+- Phase: 1.2.4 persistent memory delivery release candidate
+- Branch: `codex/1.2.4-persistent-memory-delivery`
+- Last updated: 2026-07-26
+- Released baseline: `memorix@1.2.3`, tag `v1.2.3`, `origin/main` at
+  `03ceb6d`.
+- Goal: make the existing persistent memory layer deliver useful prior work
+  naturally across MCP and CLI without turning ordinary tasks into historical
+  context dumps.
+
+## 1.2.4 Persistent Memory Delivery
+- Continuation is now a bounded delivery projection over existing sessions and
+  durable observations, not a second handoff database. `TaskWorkset` keeps its
+  task lens (`bugfix`, `feature`, and so on) while independently recognizing a
+  continuation request.
+- A continuation Workset includes at most the latest meaningful completed
+  session summary plus three readable durable memory anchors. Each item is
+  visible in the existing `ContextReceipt`; ordinary tasks do not receive it.
+- `memorix resume "<task>"` is the CLI-equivalent continuation entry. The
+  existing MCP `memorix_project_context` receives the same behavior from the
+  user's task text, so the micro MCP profile stays at seven tools.
+- Setup-generated rules now use a single fallback call when MCP is genuinely
+  unavailable: `memorix resume` for prior work or `memorix context` for new
+  work. They explicitly forbid help probing, command enumeration, and broad
+  search loops before the first brief.
+- The visibility reader is carried into continuation retrieval, preserving
+  project aliases while failing closed for other agents' personal memory.
+- Continuation text preserves whole technical identifiers instead of emitting a
+  misleading partial token. MCP Project Context also establishes a short-lived
+  delivery boundary: a follow-up search/detail request does not re-send an
+  already represented record unless the caller names a missing fact or the user
+  explicitly asks for the underlying detail.
+- A read-only or "do not modify files" Autopilot task blocks `memorix_store`
+  by default. The only override is an explicit user request to persist a
+  record, represented by `overrideReadOnly: true`.
+- A real Codex user-path smoke, in a fresh Git fixture seeded only through the
+  public CLI, made one natural-language continuation request. Codex received
+  the bounded brief, used one specific Context Pack expansion, was stopped
+  from re-reading already-covered memory, made no `memorix_store` write, and
+  returned the correct read-only next step.
+- Completed local gates: TypeScript check, production build, focused
+  continuation/hook/CLI regressions, and the full suite (`237` files / `2677`
+  tests). A fresh packed install with optional native dependencies omitted used
+  Node SQLite to persist the same `memorix.db`; CLI resume retained
+  `AUTH_REFRESH_V2`; the micro MCP package surface exposed exactly seven tools
+  and enforced duplicate-retrieval plus read-only-write boundaries; and an
+  isolated Codex global setup wrote/activated the versioned Personal-marketplace
+  plugin with the matching skill guidance. Pending release gates: CI and
+  publish.
 
 ## 1.2.3 Session Context Visibility Hotfix
 - A real installed-package CLI smoke found that a second coordination identity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "Local-first shared memory layer for AI coding agents across MCP clients, Git history, reasoning context, and project sessions.",
   "type": "module",
   "sideEffects": false,

package/plugins/codex/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "Shared workspace memory for Codex and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/src/cli/capability-map.ts

@@ -3,7 +3,7 @@ export const CLI_NATIVE_PARITY: Record<string, string> = Object.freeze({
   memorix_search: 'memorix memory search',
   memorix_detail: 'memorix memory detail',
   memorix_graph_context: 'memorix memory graph-context',
-  memorix_project_context: 'memorix context',
+  memorix_project_context: 'memorix context|resume',
   memorix_context_pack: 'memorix codegraph context-pack',
   memorix_codegraph_status: 'memorix codegraph status',
   memorix_knowledge: 'memorix knowledge init|status|compile|lint|apply|workflow',

package/src/cli/command-guide.ts

@@ -39,7 +39,10 @@ const GUIDES: Record<string, CliCommandGuide> = {
   },
   context: {
     summary: 'Build the bounded task Workset used to resume or begin real work.',
-    usage: ['memorix context --task "continue the release fix" [--refresh auto|always|never]'],
+    usage: [
+      'memorix context "continue the release fix" [--refresh auto|always|never]',
+      'memorix resume "continue the release fix" [--refresh auto|always|never]',
+    ],
   },
   explain: {
     summary: 'Show why a task context contains its current facts and memory evidence.',

package/src/cli/commands/agent-integrations.ts

@@ -776,7 +776,11 @@ function isCurrentGuidance(content: string): boolean {
   return (
     content.includes('Memory Autopilot') &&
     content.includes('Default first step for non-trivial coding work') &&
-    content.includes('memorix_project_context')
+    content.includes('memorix_project_context') &&
+    content.includes('memorix resume') &&
+    content.includes('Continuation fallback is mandatory') &&
+    content.includes('Do not call more Memorix retrieval tools') &&
+    content.includes('read-only work')
   );
 }
 

package/src/cli/commands/codegraph.ts

@@ -60,7 +60,7 @@ function formatUsageHint(): string {
     '  memorix codegraph status --json',
     '  memorix codegraph context-pack --task "continue auth bug"',
     '',
-    'Tip: use `memorix context --task "..."` for the default agent-ready project context.',
+    'Tip: use `memorix context "..."` for new work or `memorix resume "..."` for prior work.',
   ].join('\n');
 }
 

package/src/cli/commands/context.ts

@@ -22,11 +22,16 @@ export default defineCommand({
   },
   args: {
     task: { type: 'string', description: 'Current task for context shaping' },
+    input: { type: 'positional', description: 'Current task for context shaping (ergonomic positional form)' },
+    resume: { type: 'boolean', description: 'Always include the bounded prior-work projection' },
     refresh: { type: 'string', description: 'Project scan policy: auto, always, or never' },
     json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
   },
   run: async ({ args }) => {
     const asJson = !!args.json;
+    const task = (args.task as string | undefined)?.trim()
+      || (args.input as string | undefined)?.trim()
+      || undefined;
 
     try {
       const { project, dataDir, reader } = await getCliProjectContext();
@@ -34,8 +39,10 @@ export default defineCommand({
         project,
         dataDir,
         observations: filterReadableObservations(getAllObservations(), reader),
-        task: args.task as string | undefined,
+        task,
         refresh: coerceRefreshMode(args.refresh as string | undefined),
+        reader,
+        ...(args.resume ? { continuation: 'always' as const } : {}),
       });
 
       emitResult(
@@ -49,6 +56,7 @@ export default defineCommand({
           providerQuality: context.providerQuality,
           workset: context.workset,
           ...(context.task ? { task: context.task } : {}),
+          ...(context.continuation ? { continuation: context.continuation } : {}),
         },
         formatAutoProjectContextPrompt(context),
         asJson,

package/src/cli/commands/resume.ts

@@ -0,0 +1,31 @@
+import { defineCommand } from 'citty';
+import contextCommand from './context.js';
+
+/**
+ * A human- and agent-friendly continuation entry point. It deliberately
+ * delegates to Project Context so CLI and MCP keep one Workset contract.
+ */
+export default defineCommand({
+  meta: {
+    name: 'resume',
+    description: 'Resume prior project work with one bounded Memory Autopilot brief',
+  },
+  args: {
+    task: { type: 'positional', description: 'Current continuation task', required: false },
+    refresh: { type: 'string', description: 'Project scan policy: auto, always, or never' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  async run({ args }) {
+    await contextCommand.run?.({
+      args: {
+        _: [],
+        input: args.task,
+        refresh: args.refresh,
+        json: args.json,
+        resume: true,
+      },
+      rawArgs: [],
+      cmd: contextCommand,
+    } as any);
+  },
+});

package/src/cli/index.ts

@@ -1045,6 +1045,7 @@ const main = defineCommand({
     integrate: () => import('./commands/integrate.js').then(m => m.default),
     memory: () => import('./commands/memory.js').then(m => m.default),
     context: () => import('./commands/context.js').then(m => m.default),
+    resume: () => import('./commands/resume.js').then(m => m.default),
     explain: () => import('./commands/explain.js').then(m => m.default),
     codegraph: () => import('./commands/codegraph.js').then(m => m.default),
     knowledge: () => import('./commands/knowledge.js').then(m => m.default),
@@ -1115,7 +1116,7 @@ const main = defineCommand({
     // Detect by checking if the first CLI arg matches a registered subcommand name.
     const firstArg = process.argv[2];
     const knownSubs = ['ask', 'search', 'remember', 'recent', 'help', 'workbench', 'memcode', 'config',
-      'init', 'setup', 'integrate', 'memory', 'context', 'explain', 'codegraph', 'knowledge', 'reasoning', 'retention', 'formation', 'audit', 'transfer', 'skills', 'identity',
+      'init', 'setup', 'integrate', 'memory', 'context', 'resume', 'explain', 'codegraph', 'knowledge', 'reasoning', 'retention', 'formation', 'audit', 'transfer', 'skills', 'identity',
       'session', 'team', 'task', 'message', 'lock', 'handoff', 'poll',
       'receipt',
       'serve', 'serve-http', 'status', 'sync',
@@ -1155,6 +1156,7 @@ const main = defineCommand({
       console.error('  session    Start/end/context for coding sessions');
       console.error('  memory     Search/store/detail/timeline/resolve observations');
       console.error('  context    Show the Memory Autopilot brief for this project');
+      console.error('  resume     Resume prior work with one bounded project brief');
       console.error('  explain    Explain where Memorix project context comes from');
       console.error('  codegraph  Refresh/status/context-pack for CodeGraph Memory');
       console.error('  knowledge  Review source-backed knowledge pages and project workflows');

package/src/codegraph/auto-context.ts

@@ -1,9 +1,11 @@
 import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
+import { truncateToTokenBudget } from '../compact/token-budget.js';
 import { getResolvedConfig } from '../config/resolved-config.js';
 import { buildTaskWorkset, type TaskWorkset, type WorksetCaution } from '../knowledge/workset.js';
 import type { ContextDeliveryTarget } from '../knowledge/context-assembly.js';
-import type { ProjectInfo } from '../types.js';
+import { sanitizeCredentials } from '../memory/secret-filter.js';
+import type { ObservationReader, ProjectInfo } from '../types.js';
 import { backfillMissingObservationCodeRefs, type CodeRefBackfillResult } from './binder.js';
 import { collectCurrentProjectFacts, formatGitFact, type CurrentProjectFacts } from './current-facts.js';
 import { refreshProjectLite } from './lite-provider.js';
@@ -21,7 +23,10 @@ import {
 } from './project-context.js';
 import { CodeGraphStore } from './store.js';
 import { isEligibleForAutomaticDelivery } from '../memory/admission.js';
+import { getSessionResumeBrief, type SessionResumeBrief } from '../memory/session.js';
+import { initSessionStore } from '../store/session-store.js';
 import {
+  isContinuationTask,
   lensPathCandidates,
   lensVerificationHints,
   rankLensPaths,
@@ -50,6 +55,8 @@ export interface AutoProjectContext {
   explain: ProjectContextExplain;
   refresh: AutoContextRefreshResult;
   providerQuality: CodeGraphProviderQuality;
+  /** Present only when the caller asked to continue prior work. */
+  continuation?: SessionResumeBrief;
   workset: TaskWorkset;
 }
 
@@ -123,6 +130,10 @@ export async function buildAutoProjectContext(input: {
   maxFileBytes?: number;
   /** Test-only injection point; production uses the bounded local runner. */
   externalRunner?: ExternalCodeGraphRunner;
+  /** Reader used when continuation retrieval loads session and durable memory evidence. */
+  reader?: ObservationReader;
+  /** Auto detects continuation language; always is used by the explicit resume path. */
+  continuation?: 'auto' | 'always' | 'never';
   /**
    * When supplied, a needed refresh is queued instead of running in this
    * request. MCP and hook callers use this to keep their response path fast.
@@ -135,6 +146,8 @@ export async function buildAutoProjectContext(input: {
   const now = input.now ?? new Date();
   const task = input.task?.trim();
   const lens = resolveTaskLens(task);
+  const continuationRequested = input.continuation === 'always'
+    || (input.continuation !== 'never' && isContinuationTask(task));
   const codegraphConfig = getResolvedConfig({ projectRoot: input.project.rootPath }).codegraph;
   const exclude = input.exclude ?? codegraphConfig.excludePatterns;
   const maxFileBytes = input.maxFileBytes ?? codegraphConfig.maxFileBytes;
@@ -278,6 +291,14 @@ export async function buildAutoProjectContext(input: {
   if (externalCaution) {
     runtimeCautions.push({ kind: 'external-codegraph-fallback', message: externalCaution });
   }
+  // Project Context is also used by lightweight callers that have not touched
+  // session APIs yet. Initialize only when continuation was requested so a
+  // normal Workset remains independent of session persistence.
+  let continuation: SessionResumeBrief | undefined;
+  if (continuationRequested) {
+    await initSessionStore(input.dataDir);
+    continuation = await getSessionResumeBrief(input.project.id, task, input.reader);
+  }
   const workset = await buildTaskWorkset({
     projectId: input.project.id,
     dataDir: input.dataDir,
@@ -287,6 +308,7 @@ export async function buildAutoProjectContext(input: {
     ...(externalOutline ? { semanticCode: externalOutline } : {}),
     providerQuality,
     currentFacts: worksetFactLines(currentFacts),
+    ...(continuation ? { continuation } : {}),
     codeState: codeStateLine(overview),
     reliableMemory: sourceSets.reliableSources
       .slice(0, lens.sourceLimit)
@@ -340,6 +362,7 @@ export async function buildAutoProjectContext(input: {
     explain,
     refresh,
     providerQuality,
+    ...(continuationRequested && workset.continuation ? { continuation: workset.continuation } : {}),
     workset,
   };
 }
@@ -350,6 +373,13 @@ function formatLanguages(overview: ProjectContextOverview): string {
     : 'none indexed yet';
 }
 
+function compactContinuationText(text: string, budget: number): string {
+  return truncateToTokenBudget(
+    sanitizeCredentials(text).replace(/\s+/g, ' ').trim(),
+    budget,
+  );
+}
+
 function codeStateLine(overview: ProjectContextOverview): string {
   const snapshot = overview.code.latestSnapshot;
   if (!snapshot) return '- Code state: no completed snapshot yet';
@@ -533,6 +563,29 @@ export function formatAutoProjectContextSummary(context: AutoProjectContext): st
       : '- none yet',
   );
 
+  const continuation = context.workset.continuation;
+  if (continuation?.previousSession || continuation?.memories.length) {
+    lines.push('', 'Resume from prior work');
+    if (continuation.previousSession) {
+      const session = continuation.previousSession;
+      const source = [session.agent, session.endedAt ? session.endedAt.slice(0, 10) : undefined]
+        .filter(Boolean)
+        .join(', ');
+      lines.push(
+        '- Previous session' + (source ? ` (${source})` : '') + ': '
+          + compactContinuationText(session.summary, 44),
+      );
+    }
+    for (const memory of continuation.memories.slice(0, 3)) {
+      const detail = memory.detail ? ': ' + compactContinuationText(memory.detail, 20) : '';
+      lines.push(
+        '- #' + memory.id + ' ' + memory.type + ': '
+          + compactContinuationText(memory.title, 18)
+          + detail,
+      );
+    }
+  }
+
   return lines.join('\n');
 }
 

package/src/codegraph/task-lens.ts

@@ -121,6 +121,7 @@ const KEYWORDS: Record<Exclude<TaskLensId, 'general'>, string[]> = {
     'fail',
     'failing',
     'fix',
+    'fixing',
     'issue',
     'regression',
     'repro',
@@ -139,6 +140,22 @@ const KEYWORDS: Record<Exclude<TaskLensId, 'general'>, string[]> = {
   test: ['coverage', 'fixture', 'smoke', 'spec', 'test', 'tests', 'testing', 'vitest', '测试'],
 };
 
+// Continuation is a delivery intent, not a task lens. A request can both resume
+// prior work and be a bugfix, feature, or release task, so callers keep the
+// normal lens and add a bounded prior-work projection separately.
+const CONTINUATION_KEYWORDS = [
+  'continue',
+  'resume',
+  'pick up',
+  'carry on',
+  'previous session',
+  '继续',
+  '接手',
+  '恢复',
+  '延续',
+  '上次会话',
+];
+
 const LENS_PRIORITY: Exclude<TaskLensId, 'general'>[] = [
   'bugfix',
   'release',
@@ -229,6 +246,18 @@ export function resolveTaskLens(task?: string): TaskLens {
   return best.score > 0 ? LENSES[best.id] : LENSES.general;
 }
 
+/**
+ * Detect when the caller is asking to continue existing work. This stays
+ * separate from task-lens routing so "continue fixing the timeout" remains a
+ * bugfix, while still receiving a compact prior-work brief.
+ */
+export function isContinuationTask(task?: string): boolean {
+  const normalized = (task ?? '').trim().toLowerCase();
+  return normalized.length > 0 && CONTINUATION_KEYWORDS.some((keyword) =>
+    containsTaskKeyword(normalized, keyword),
+  );
+}
+
 function pathKindScore(path: string, lens: TaskLens): number {
   const normalized = normalizePath(path).toLowerCase();
   const name = normalized.split('/').pop() ?? normalized;

package/src/compact/token-budget.ts

@@ -56,7 +56,22 @@ export function truncateToTokenBudget(text: string, budget: number): string {
       result = result.slice(0, Math.floor(result.length * 0.9));
     }
     if (result.length < text.length) {
-      result += '...';
+      // A character estimate can end halfway through a flag, path, or symbol.
+      // Drop the incomplete whitespace-delimited token instead of returning
+      // misleading fragments such as `AUTH...`.
+      const nextCharacter = text.charAt(result.length);
+      if (nextCharacter && !/[\s.,;:!?)}\]]/.test(nextCharacter)) {
+        const boundary = result.search(/\s+\S*$/);
+        result = boundary > 0 ? result.slice(0, boundary).trimEnd() : '';
+      }
+
+      // Keep the suffix inside the stated budget when there is room. An empty
+      // prefix is more honest than a partial identifier that appears valid.
+      while (result && fitsInBudget(result + '...', budget) === false) {
+        const boundary = result.lastIndexOf(' ');
+        result = boundary > 0 ? result.slice(0, boundary).trimEnd() : '';
+      }
+      result = result ? result + '...' : '...';
     }
   }
 

package/src/config/toml-loader.ts

@@ -144,6 +144,9 @@ function parseTomlValue(raw: string, filePath: string, line: number): unknown {
   if (raw.startsWith('"') && raw.endsWith('"')) {
     return raw.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
   }
+  if (raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
   if (raw === 'true') return true;
   if (raw === 'false') return false;
   if (/^-?\d+$/.test(raw)) return Number.parseInt(raw, 10);
@@ -157,7 +160,7 @@ function parseTomlValue(raw: string, filePath: string, line: number): unknown {
 }
 
 function stripComment(line: string): string {
-  let inString = false;
+  let quote: '"' | "'" | null = null;
   let escaped = false;
   for (let i = 0; i < line.length; i++) {
     const char = line[i];
@@ -165,15 +168,16 @@ function stripComment(line: string): string {
       escaped = false;
       continue;
     }
-    if (char === '\\' && inString) {
+    if (char === '\\' && quote === '"') {
       escaped = true;
       continue;
     }
-    if (char === '"') {
-      inString = !inString;
+    if (char === '"' || char === "'") {
+      if (quote === char) quote = null;
+      else if (quote === null) quote = char;
       continue;
     }
-    if (char === '#' && !inString) {
+    if (char === '#' && quote === null) {
       return line.slice(0, i);
     }
   }