memorix 1.2.3 → 1.2.5

package/src/hooks/handler.ts

@@ -22,6 +22,9 @@ import { detectBestPattern, patternToObservationType } from './pattern-detector.
 import { isSignificantKnowledge, isRetrievedResult, isTrivialCommand } from './significance-filter.js';
 import type { AgentName, HookEvent, HookOutput, NormalizedHookInput } from './types.js';
 
+type HookInjectionMode = 'full' | 'minimal' | 'silent';
+type HookContextTarget = 'hook-session-start' | 'hook-user-prompt';
+
 // ─── Constants ───
 
 /** Observation type → emoji mapping (single source of truth) */
@@ -282,16 +285,117 @@ function buildObservation(
 
 // ─── Session Start Handler ───
 
+async function getHookInjectionMode(input: NormalizedHookInput): Promise<HookInjectionMode> {
+  try {
+    const { getBehaviorConfig } = await import('../config/behavior.js');
+    return getBehaviorConfig({ projectRoot: input.cwd || undefined }).sessionInject;
+  } catch {
+    return 'minimal';
+  }
+}
+
+/**
+ * Assemble the one bounded project brief shared by hook delivery points.
+ * Hooks never retrieve a transcript: this returns only the normal Workset.
+ */
+async function buildHookProjectContext(
+  input: NormalizedHookInput,
+  task: string,
+  target: HookContextTarget,
+): Promise<{ prompt: string; hasContinuation: boolean } | null> {
+  try {
+    const { detectProject } = await import('../project/detector.js');
+    const { getProjectDataDir } = await import('../store/persistence.js');
+    const { initObservationStore, getObservationStore: getStore } = await import('../store/obs-store.js');
+    const { initMiniSkillStore } = await import('../store/mini-skill-store.js');
+    const { initSessionStore } = await import('../store/session-store.js');
+    const { initAliasRegistry, registerAlias } = await import('../project/aliases.js');
+    const { MaintenanceTargetStore } = await import('../runtime/maintenance-targets.js');
+    const { buildAutoProjectContext, formatAutoProjectContextPrompt } = await import('../codegraph/auto-context.js');
+    const { filterReadableObservations } = await import('../memory/visibility.js');
+
+    const rawProject = detectProject(input.cwd || process.cwd());
+    if (!rawProject) return null;
+    const dataDir = await getProjectDataDir(rawProject.id);
+
+    initAliasRegistry(dataDir);
+    const canonicalId = await registerAlias(rawProject);
+    new MaintenanceTargetStore(dataDir).register({
+      projectId: canonicalId,
+      projectRoot: rawProject.rootPath,
+      dataDir,
+    });
+    await initObservationStore(dataDir);
+    await initMiniSkillStore(dataDir);
+    await initSessionStore(dataDir);
+    const activeObservations = filterReadableObservations(
+      await getStore().loadByProject(canonicalId, { status: 'active' }),
+      { projectId: canonicalId },
+    );
+    const context = await buildAutoProjectContext({
+      project: { ...rawProject, id: canonicalId },
+      dataDir,
+      observations: activeObservations,
+      task,
+      refresh: 'auto',
+      reader: { projectId: canonicalId },
+      continuation: 'always',
+      enqueueRefresh: () => import('../runtime/lifecycle.js').then(({ enqueueCodegraphRefresh }) => {
+        enqueueCodegraphRefresh({
+          dataDir,
+          projectId: canonicalId,
+          source: target === 'hook-user-prompt' ? 'hook-user-prompt' : 'hook-session-start',
+          maxFiles: 5_000,
+        });
+      }),
+      deliveryTarget: target,
+    });
+
+    return {
+      prompt: formatAutoProjectContextPrompt(context),
+      hasContinuation: Boolean(
+        context.continuation?.previousSession || (context.continuation?.memories.length ?? 0) > 0,
+      ),
+    };
+  } catch (error) {
+    // A context hint must never interrupt the host's turn. The structured
+    // error is intentionally kept in stderr for hook diagnostics.
+    console.error('[memorix] hook context failed:', (error as Error)?.message ?? error);
+    return null;
+  }
+}
+
+/**
+ * Claude Code ignores SessionStart systemMessage as model context. Its official
+ * UserPromptSubmit output accepts additionalContext, so explicit continuation
+ * requests are delivered there instead of relying on a rules-file suggestion.
+ */
+async function buildClaudeContinuationPromptContext(input: NormalizedHookInput): Promise<string | undefined> {
+  if (input.agent !== 'claude' || input.event !== 'user_prompt' || !input.userPrompt?.trim()) {
+    return undefined;
+  }
+
+  const { isContinuationTask } = await import('../codegraph/task-lens.js');
+  if (!isContinuationTask(input.userPrompt)) return undefined;
+
+  if (await getHookInjectionMode(input) === 'silent') return undefined;
+
+  const context = await buildHookProjectContext(input, input.userPrompt, 'hook-user-prompt');
+  if (!context?.hasContinuation) return undefined;
+
+  return [
+    'Memorix prepared a bounded prior-work brief for this explicit continuation request.',
+    'Treat it as background context; current code wins. Use it before broad Git or file-history archaeology.',
+    '',
+    context.prompt,
+  ].join('\n');
+}
+
 async function handleSessionStart(input: NormalizedHookInput): Promise<{
   observation: ReturnType<typeof buildObservation> | null;
   output: HookOutput;
 }> {
-  // Check behavior config for session injection level
-  let injectMode: 'full' | 'minimal' | 'silent' = 'minimal';
-  try {
-    const { getBehaviorConfig } = await import('../config/behavior.js');
-    injectMode = getBehaviorConfig().sessionInject;
-  } catch { /* default to minimal */ }
+  const injectMode = await getHookInjectionMode(input);
 
   if (injectMode === 'silent') {
     return { observation: null, output: { continue: true } };
@@ -299,55 +403,8 @@ async function handleSessionStart(input: NormalizedHookInput): Promise<{
 
   let contextSummary = '';
   if (injectMode === 'full') {
-    try {
-      const { detectProject } = await import('../project/detector.js');
-      const { getProjectDataDir } = await import('../store/persistence.js');
-      const { initObservationStore, getObservationStore: getStore } = await import('../store/obs-store.js');
-      const { initMiniSkillStore } = await import('../store/mini-skill-store.js');
-      const { initSessionStore } = await import('../store/session-store.js');
-      const { initAliasRegistry, registerAlias } = await import('../project/aliases.js');
-      const { MaintenanceTargetStore } = await import('../runtime/maintenance-targets.js');
-      const { buildAutoProjectContext, formatAutoProjectContextPrompt } = await import('../codegraph/auto-context.js');
-      const { filterReadableObservations } = await import('../memory/visibility.js');
-
-      const rawProject = detectProject(input.cwd || process.cwd());
-      if (!rawProject) throw new Error('No .git found');
-      const dataDir = await getProjectDataDir(rawProject.id);
-
-      initAliasRegistry(dataDir);
-      const canonicalId = await registerAlias(rawProject);
-      new MaintenanceTargetStore(dataDir).register({
-        projectId: canonicalId,
-        projectRoot: rawProject.rootPath,
-        dataDir,
-      });
-      await initObservationStore(dataDir);
-      await initMiniSkillStore(dataDir);
-      await initSessionStore(dataDir);
-      const activeObservations = filterReadableObservations(
-        await getStore().loadByProject(canonicalId, { status: 'active' }),
-        { projectId: canonicalId },
-      );
-      const context = await buildAutoProjectContext({
-        project: { ...rawProject, id: canonicalId },
-        dataDir,
-        observations: activeObservations,
-        refresh: 'auto',
-        enqueueRefresh: () => import('../runtime/lifecycle.js').then(({ enqueueCodegraphRefresh }) => {
-            enqueueCodegraphRefresh({
-              dataDir,
-              projectId: canonicalId,
-              source: 'hook-session-start',
-              maxFiles: 5_000,
-            });
-          }),
-        deliveryTarget: 'hook-session-start',
-      });
-      contextSummary = `\n\n${formatAutoProjectContextPrompt(context)}`;
-    } catch (sessErr) {
-      // Diagnostic log — session start context injection failed
-      console.error('[memorix] session start context failed:', (sessErr as Error)?.message ?? sessErr);
-    }
+    const context = await buildHookProjectContext(input, 'Continue the current task.', 'hook-session-start');
+    if (context) contextSummary = `\n\n${context.prompt}`;
   }
 
   // Build system message based on inject mode
@@ -378,6 +435,10 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
   output: HookOutput;
 }> {
   const defaultOutput: HookOutput = { continue: true };
+  const continuationMessage = await buildClaudeContinuationPromptContext(input);
+  const output = continuationMessage
+    ? { ...defaultOutput, systemMessage: continuationMessage }
+    : defaultOutput;
 
   // ─── Session lifecycle (special handling) ───
   if (input.event === 'session_start') {
@@ -386,7 +447,7 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
   if (input.event === 'session_end') {
     const endContent = extractContent(input);
     if (endContent.length < 50) {
-      return { observation: null, output: defaultOutput };
+      return { observation: null, output };
     }
     const draft = buildObservation(input, endContent, 'unknown');
     const admission = assessHookAdmission({
@@ -399,13 +460,13 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
       observation: admission.action === 'store'
         ? buildObservation(input, endContent, 'unknown', admission)
         : null,
-      output: defaultOutput,
+      output,
     };
   }
   if (input.event === 'post_compact') {
     // Post-compaction: acknowledge the event, no observation needed.
     // The real value is the side-effect (runHook pipe) already handled by the plugin.
-    return { observation: null, output: defaultOutput };
+    return { observation: null, output };
   }
 
   // ─── Classify & extract ───
@@ -415,7 +476,7 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
 
   // Never-store category (memorix's own tools)
   if (policy.store === 'never') {
-    return { observation: null, output: defaultOutput };
+    return { observation: null, output };
   }
 
   // ─── Significance Filter (Cipher-style noise rejection) ───
@@ -423,13 +484,13 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
   if (category === 'command' && input.command) {
     const realCmd = extractRealCommand(input.command);
     if (isTrivialCommand(realCmd)) {
-      return { observation: null, output: defaultOutput };
+      return { observation: null, output };
     }
   }
 
   // Skip retrieved/search results (prevent memory pollution)
   if (isRetrievedResult(content)) {
-    return { observation: null, output: defaultOutput };
+    return { observation: null, output };
   }
 
   // Minimum length gate
@@ -437,7 +498,7 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
     ? MIN_PROMPT_LENGTH
     : policy.minLength;
   if (content.length < minLen) {
-    return { observation: null, output: defaultOutput };
+    return { observation: null, output };
   }
 
   // User prompts & AI responses are direct interaction — check significance
@@ -450,7 +511,7 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
   if (effectiveStore !== 'always') {
     const significance = isSignificantKnowledge(content);
     if (!significance.isSignificant) {
-      return { observation: null, output: defaultOutput };
+      return { observation: null, output };
     }
   }
 
@@ -459,14 +520,14 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
     const pattern = detectBestPattern(content);
     const significance = isSignificantKnowledge(content);
     if (!pattern && content.length < 200 && !significance.isSignificant) {
-      return { observation: null, output: defaultOutput };
+      return { observation: null, output };
     }
   }
 
   // Cooldown (per-file or per-command, not per-tool-category)
   const cooldownKey = buildCooldownKey(input, content);
   if (isInCooldown(cooldownKey)) {
-    return { observation: null, output: defaultOutput };
+    return { observation: null, output };
   }
   markTriggered(cooldownKey);
 
@@ -481,7 +542,7 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
     observation: admission.action === 'store'
       ? buildObservation(input, content, category, admission)
       : null,
-    output: defaultOutput,
+    output,
   };
 }
 

package/src/hooks/installers/index.ts

@@ -1210,17 +1210,18 @@ function getAgentRulesContent(agent?: AgentName, scope: 'project' | 'global' = '
     '',
     '## Start with Memory Autopilot',
     '',
-    `Default first step for non-trivial coding work: call \x60memorix_project_context\x60 with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). Treat its "Start here" files as the first ${contextNoun} files to inspect.`,
+    `Default first step for non-trivial coding work: call \x60memorix_project_context\x60 with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). When the task is continuing prior work, the same brief also includes a bounded prior-work projection. Treat its "Start here" files as the first ${contextNoun} files to inspect.`,
     '',
-    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select \x60memorix_project_context\x60 first. Run \x60memorix context --task "<task>"\x60 only after MCP is unavailable, disabled, or not discoverable, and pass the user\'s real task text. Do not skip memory, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
+    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select \x60memorix_project_context\x60 first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user\'s real task before inspecting files, Git history, progress notes, or guessing: \x60memorix resume "<task>" --json\x60. For a new task, use \x60memorix context "<task>" --json\x60 instead. The absence of \x60.memorix\x60 or visible memory files never proves project memory is empty. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
     '',
-    'Use \x60memorix_context_pack\x60 when you need structured refs and freshness for code-bound memories.',
+    'After a successful \x60memorix_project_context\x60 result, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use \x60memorix_context_pack\x60, \x60memorix_search\x60, or \x60memorix_detail\x60 only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in \x60purpose\x60 when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.',
+    'If the user asks for read-only work or says not to modify files, do not call \x60memorix_store\x60 just to record an assessment. Store only when the user explicitly asks to preserve it.',
     '',
     '## When to search memory',
     '',
     'Use \x60memorix_graph_context\x60 for explicit memory graph questions or broad graph overview after the autopilot brief is not enough.',
     '',
-    `Use \x60memorix_search\x60 when prior ${contextNoun} context would help — for example:`,
+    `Use \x60memorix_search\x60 when prior ${contextNoun} context would help and the Autopilot brief did not already answer the question — for example:`,
     '- The user asks about a past decision, bug, or change',
     '- You need to understand why something was designed a certain way',
     "- You're continuing work that started in a previous session",

package/src/hooks/official-skills.ts

@@ -31,7 +31,8 @@ export const OFFICIAL_MEMORIX_SKILLS: OfficialMemorixSkill[] = [
       '',
       '| Situation | Prefer | CLI fallback |',
       '|---|---|---|',
-      '| Starting or continuing a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context --task "<task>"` |',
+      '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --json` |',
+      '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --json` |',
       '| Need structured refs/freshness for code-bound memories | `memorix_context_pack` | `memorix codegraph context-pack --task "<topic>"` |',
       '| Explicit memory graph question | `memorix_graph_context` | `memorix memory graph-context --query "<topic>"` |',
       '| Specific past decision, bug, file, or change | `memorix_search` | `memorix memory search --query "<topic>"` |',
@@ -44,9 +45,10 @@ export const OFFICIAL_MEMORIX_SKILLS: OfficialMemorixSkill[] = [
       '',
       '- Default first step for non-trivial coding work: call `memorix_project_context` before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Pass the user\'s actual task so Memorix can choose a bugfix, feature, release, onboarding, refactor, docs, test, or general brief. Start by reading its suggested files.',
       '- In Claude Code headless/print-mode, an initial MCP `pending` status is not a failure by itself. Prefer MCP first: use the client\'s tool discovery/dynamic loading to find `memorix_project_context` when it is not in the first visible tool list.',
-      '- Run `memorix context --task "<task>"` from the shell only after MCP is unavailable, disabled, or not discoverable, and pass the user\'s real task text. Do not skip memory, wait indefinitely on `pending`, or hand-write tool-call syntax.',
-      '- Use `memorix_search` for a specific decision, bug, file, or prior change that the project context did not answer.',
-      '- Fetch detail before relying on a specific memory.',
+      '- Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run `memorix resume "<task>" --json` exactly once before inspecting files, Git history, progress notes, or guessing. The absence of `.memorix` or visible memory files never proves project memory is empty. For a new task, use `memorix context "<task>" --json` instead. If that one command fails, report it and proceed normally; do not probe help, enumerate commands, or chain broad searches.',
+      '- After a successful `memorix_project_context`, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use Context Pack, search, or detail only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.',
+      '- If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.',
+      '- Use `memorix_search` for a specific decision, bug, file, or prior change that the project context did not answer. Fetch detail only for a result you still need after the brief.',
       '- Treat current code-bound memory as a map. Treat stale, suspect, or unbound memory as a lead that must be verified against the current code.',
       '- Skip memory lookup for greetings, tiny one-off edits, or questions fully answered by the current file.',
       '- If a fresh project has no memories, proceed normally and do not repeat the same empty search in the same turn.',

package/src/hooks/rules/memorix-agent-rules.md

@@ -7,13 +7,15 @@ You have access to Memorix memory tools. Follow these rules to maintain persiste
 At the beginning of non-trivial coding work, use Memorix Memory Autopilot before local progress notes or broad file exploration. A session bind is not required for every conversation.
 
 1. Default first step for non-trivial coding work: call `memorix_project_context` with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). Treat its "Start here" files as the first code or docs to inspect.
-2. If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` first. Run `memorix context --task "<task>"` only after MCP is unavailable, disabled, or not discoverable, and pass the user's real task text. Do not skip memory, wait indefinitely on MCP startup, or hand-write tool-call syntax.
-3. Use `memorix_context_pack` when you need structured refs and freshness for code-bound memories.
-4. For broad memory graph questions, call `memorix_graph_context` to get a compact background packet.
-5. For specific past decisions, bugs, files, or changes, call `memorix_search` with a focused query.
-6. If search results are found, use `memorix_detail` only for the few refs you actually need.
-7. Call `memorix_session_start` only when explicit session semantics are useful: handoff, long-running work, orchestration coordination, restoring prior session context, or HTTP project binding.
-8. Reference relevant memories naturally in your response; do not just list them.
+2. If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user's real task before inspecting files, Git history, progress notes, or guessing: use `memorix resume "<task>" --json`. For a new task, use `memorix context "<task>" --json` instead. The absence of `.memorix` or visible memory files never proves project memory is empty. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax.
+3. After a successful `memorix_project_context` result, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use `memorix_context_pack`, `memorix_search`, or `memorix_detail` only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.
+   If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.
+4. Use `memorix_context_pack` when you need structured refs and freshness for code-bound memories.
+5. For broad memory graph questions, call `memorix_graph_context` to get a compact background packet after the Autopilot brief is not enough.
+6. For a specific past decision, bug, file, or change that the brief did not answer, call `memorix_search` with a focused query.
+7. If search results are found, use `memorix_detail` only for the few refs you actually need.
+8. Call `memorix_session_start` only when explicit session semantics are useful: handoff, long-running work, orchestration coordination, restoring prior session context, or HTTP project binding.
+9. Reference relevant memories naturally in your response; do not just list them.
 
 If `memorix_search` says this is a fresh project with no Memorix memories yet, treat that as a successful cold-start signal. Do not repeat `memorix_search` again in the same turn unless the user explicitly asks for history/context, or new memories were written during the turn.
 

package/src/knowledge/context-assembly.ts

@@ -7,10 +7,12 @@ export type ContextDeliveryTarget =
   | 'project-context'
   | 'context-pack'
   | 'hook-session-start'
+  | 'hook-user-prompt'
   | 'session-handoff';
 
 export type ContextCandidateKind =
   | 'task'
+  | 'continuation'
   | 'current-fact'
   | 'code-state'
   | 'semantic-code'
@@ -41,7 +43,7 @@ export interface ContextReceiptOmission {
 }
 
 export interface ContextReceipt {
-  version: '1.2.2';
+  version: '1.2.4';
   target: ContextDeliveryTarget;
   elapsedMs: number;
   budget: {
@@ -58,6 +60,7 @@ function displayTarget(target: ContextDeliveryTarget): string {
     case 'project-context': return 'Project Context';
     case 'context-pack': return 'Context Pack';
     case 'hook-session-start': return 'SessionStart hook';
+    case 'hook-user-prompt': return 'UserPromptSubmit hook';
     case 'session-handoff': return 'session handoff';
   }
 }

package/src/knowledge/workset.ts

@@ -77,11 +77,28 @@ export interface WorksetMemorySource {
   reason?: string;
 }
 
+/** Prior-work evidence selected only for an explicit or inferred continuation. */
+export interface WorksetContinuation {
+  previousSession?: {
+    id: string;
+    agent?: string;
+    endedAt?: string;
+    summary: string;
+  };
+  memories: Array<{
+    id: number;
+    title: string;
+    type: string;
+    detail?: string;
+  }>;
+}
+
 export interface TaskWorkset {
   version: '1.2';
   task: string;
   lens: string;
   currentFacts: string[];
+  continuation?: WorksetContinuation;
   codeState?: string;
   startHere: string[];
   /** Bounded task-specific relations from a validated local semantic graph. */
@@ -117,6 +134,7 @@ export interface BuildTaskWorksetInput {
   task?: string;
   lens: string;
   currentFacts?: string[];
+  continuation?: WorksetContinuation;
   codeState?: string;
   startHere: string[];
   semanticCode?: ExternalCodeGraphOutline;
@@ -151,6 +169,11 @@ function short(text: string, budget = 28): string {
   return countTextTokens(safe) <= budget ? safe : truncateToTokenBudget(safe, budget);
 }
 
+// A continuation anchor often contains the exact flag, path, or command that
+// makes the handoff actionable. Preserve a little more of it than generic
+// display detail; the enclosing Workset budget still decides whether it fits.
+const CONTINUATION_DETAIL_TOKEN_BUDGET = 20;
+
 function claimAssertion(claim: KnowledgeClaim): string {
   return short([claim.subject, claim.predicate, claim.objectValue].join(' '));
 }
@@ -259,6 +282,7 @@ function freshnessForMemory(status: WorksetMemorySource['status']): ContextCandi
 }
 
 function receiptOmissionKind(raw: string): ContextCandidateKind | undefined {
+  if (raw.includes('continuation')) return 'continuation';
   if (raw.includes('task')) return 'task';
   if (raw.includes('fact')) return 'current-fact';
   if (raw.includes('state')) return 'code-state';
@@ -328,6 +352,51 @@ export function renderTaskWorksetPrompt(input: Omit<TaskWorkset, 'prompt' | 'bud
   });
   appendLine(lines, 'Task lens: ' + input.lens, maxTokens, omitted, 'lens');
 
+  const hasContinuation = Boolean(
+    input.continuation?.previousSession || (input.continuation?.memories.length ?? 0) > 0,
+  );
+  if (hasContinuation && input.continuation) {
+    appendLine(lines, '', maxTokens, omitted, 'continuation-heading');
+    appendLine(lines, 'Resume from prior work', maxTokens, omitted, 'continuation-heading');
+    if (input.continuation.previousSession) {
+      const session = input.continuation.previousSession;
+      const source = [session.agent, session.endedAt ? session.endedAt.slice(0, 10) : undefined]
+        .filter(Boolean)
+        .join(', ');
+      appendLine(
+        lines,
+        '- Previous session' + (source ? ` (${source})` : '') + ': ' + short(session.summary, 44),
+        maxTokens,
+        omitted,
+        'continuation-session',
+        selected,
+        {
+          kind: 'continuation',
+          id: 'session:' + session.id,
+          reason: 'latest meaningful project session summary',
+          trust: 'historical',
+        },
+      );
+    }
+    for (const memory of input.continuation.memories.slice(0, 3)) {
+      const detail = memory.detail ? ': ' + short(memory.detail, CONTINUATION_DETAIL_TOKEN_BUDGET) : '';
+      appendLine(
+        lines,
+        '- #' + memory.id + ' ' + memory.type + ': ' + short(memory.title, 18) + detail,
+        maxTokens,
+        omitted,
+        'continuation-memory',
+        selected,
+        {
+          kind: 'continuation',
+          id: 'memory:' + memory.id,
+          reason: 'durable prior-work memory',
+          trust: 'historical',
+        },
+      );
+    }
+  }
+
   if (input.cautions.length > 0 || input.cautionMemory.length > 0) {
     appendLine(lines, '', maxTokens, omitted, 'caution-heading');
     appendLine(lines, 'Cautions', maxTokens, omitted, 'caution-heading');
@@ -629,6 +698,24 @@ export async function buildTaskWorkset(input: BuildTaskWorksetInput): Promise<Ta
   const normalizedCautions = unique(cautions.map(caution => caution.kind))
     .map(kind => cautions.find(caution => caution.kind === kind)!)
     .slice(0, 6);
+  const continuation = input.continuation
+    && (input.continuation.previousSession || input.continuation.memories.length > 0)
+    ? {
+      ...(input.continuation.previousSession
+        ? {
+          previousSession: {
+            ...input.continuation.previousSession,
+            summary: short(input.continuation.previousSession.summary, 52),
+          },
+        }
+        : {}),
+      memories: input.continuation.memories.slice(0, 3).map((memory) => ({
+        ...memory,
+        title: short(memory.title, 20),
+        ...(memory.detail ? { detail: short(memory.detail, CONTINUATION_DETAIL_TOKEN_BUDGET) } : {}),
+      })),
+    }
+    : undefined;
   const base = {
     version: '1.2' as const,
     task,
@@ -636,6 +723,7 @@ export async function buildTaskWorkset(input: BuildTaskWorksetInput): Promise<Ta
     currentFacts: input.currentFacts?.map(fact => fact.startsWith('Historical note:')
       ? short(fact, 48)
       : short(fact, 28)).slice(0, 4) ?? [],
+    ...(continuation ? { continuation } : {}),
     ...(input.codeState ? { codeState: short(input.codeState, 28) } : {}),
     startHere: unique(input.startHere).slice(0, 5),
     ...(input.semanticCode ? { semanticCode: input.semanticCode } : {}),
@@ -660,7 +748,7 @@ export async function buildTaskWorkset(input: BuildTaskWorksetInput): Promise<Ta
     budget: { maxTokens },
   });
   const receipt: ContextReceipt = {
-    version: '1.2.2',
+    version: '1.2.4',
     target: input.deliveryTarget ?? 'project-context',
     elapsedMs: Math.max(0, Date.now() - startedAt),
     budget: {