@ryuenn3123/agentic-senior-core 2.0.26 → 2.5.3

package/lib/cli/commands/init.mjs

@@ -56,6 +56,10 @@ import {
   normalizeAgentName,
   writeTokenOptimizationState,
 } from '../token-optimization.mjs';
+import {
+  createMemoryContinuityState,
+  writeMemoryContinuityState,
+} from '../memory-continuity.mjs';
 import { evaluateSkillDomainCompatibility } from '../compatibility.mjs';
 
 export { REPO_ROOT } from '../constants.mjs';
@@ -71,6 +75,7 @@ export function parseInitArguments(commandArguments) {
     ci: undefined,
     newbie: false,
     tokenOptimize: true,
+    memoryContinuity: true,
     tokenAgent: 'copilot',
     includeMcpTemplate: false,
     scaffoldDocs: undefined,
@@ -166,6 +171,11 @@ export function parseInitArguments(commandArguments) {
       continue;
     }
 
+    if (currentArgument === '--memory-continuity') {
+      parsedInitOptions.memoryContinuity = true;
+      continue;
+    }
+
     if (currentArgument === '--token-agent') {
       parsedInitOptions.tokenAgent = commandArguments[argumentIndex + 1] || 'copilot';
       argumentIndex += 1;
@@ -182,6 +192,11 @@ export function parseInitArguments(commandArguments) {
       continue;
     }
 
+    if (currentArgument === '--no-memory-continuity') {
+      parsedInitOptions.memoryContinuity = false;
+      continue;
+    }
+
     if (currentArgument === '--mcp-template') {
       parsedInitOptions.includeMcpTemplate = true;
       continue;
@@ -408,6 +423,9 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
   const isTokenOptimizationEnabled = typeof initOptions.tokenOptimize === 'boolean'
     ? initOptions.tokenOptimize
     : true;
+  const isMemoryContinuityEnabled = typeof initOptions.memoryContinuity === 'boolean'
+    ? initOptions.memoryContinuity
+    : true;
   const shouldIncludeMcpTemplate = initOptions.includeMcpTemplate === true;
   const selectedTokenAgentName = normalizeAgentName(initOptions.tokenAgent || 'copilot');
   const isInteractiveSession = Boolean(stdin.isTTY && stdout.isTTY);
@@ -729,9 +747,20 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
       includeMcpTemplate: shouldIncludeMcpTemplate,
     });
 
+    let memoryContinuityState = null;
+    if (isMemoryContinuityEnabled) {
+      memoryContinuityState = createMemoryContinuityState({
+        isEnabled: true,
+      });
+
+      await writeMemoryContinuityState(resolvedTargetDirectoryPath, memoryContinuityState);
+      console.log(`Memory continuity policy enabled (${memoryContinuityState.hydrationMode}).`);
+    }
+
+    let tokenOptimizationState = null;
     if (isTokenOptimizationEnabled) {
       const detectedExternalProxy = detectRtkBinary();
-      const tokenOptimizationState = createTokenOptimizationState({
+      tokenOptimizationState = createTokenOptimizationState({
         isEnabled: true,
         selectedAgentName: selectedTokenAgentName,
         rtkDetection: detectedExternalProxy,
@@ -862,6 +891,18 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
         detectionSource: detectedRuntimeEnvironment.source,
       },
       operationMode: 'init',
+      tokenOptimization: {
+        enabled: isTokenOptimizationEnabled,
+        selectedAgent: selectedTokenAgentName,
+        preferredShellProxy: tokenOptimizationState?.preferredShellProxy || null,
+        stateFile: isTokenOptimizationEnabled ? '.agent-context/state/token-optimization.json' : null,
+      },
+      memoryContinuity: {
+        enabled: isMemoryContinuityEnabled,
+        hydrationMode: memoryContinuityState?.hydrationMode || null,
+        adapters: memoryContinuityState?.adapters || [],
+        stateFile: isMemoryContinuityEnabled ? '.agent-context/state/memory-continuity.json' : null,
+      },
     });
 
     console.log('\nInitialization complete.');
@@ -892,6 +933,11 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
     }
     console.log(`- Repository workflows copied: no (workflows remain source-repo assets)`);
     console.log(`- MCP template file: ${shouldIncludeMcpTemplate ? 'created (.vscode/mcp.json)' : 'not created by default (use --mcp-template)'}`);
+    if (isMemoryContinuityEnabled) {
+      console.log('- Memory continuity policy: enabled (index + selective hydration)');
+    } else {
+      console.log('- Memory continuity policy: disabled (--no-memory-continuity)');
+    }
     if (isTokenOptimizationEnabled) {
       console.log(`- Token optimization policy: enabled for ${selectedTokenAgentName}`);
     } else {

package/lib/cli/compiler.mjs

@@ -25,6 +25,10 @@ import {
   readTokenOptimizationState,
   buildTokenOptimizationGuidanceBlock,
 } from './token-optimization.mjs';
+import {
+  readMemoryContinuityState,
+  buildMemoryContinuityGuidanceBlock,
+} from './memory-continuity.mjs';
 
 export async function writeSelectedPolicy(targetDirectoryPath, selectedProfileName) {
   const policyFilePath = path.join(targetDirectoryPath, '.agent-context', 'policies', POLICY_FILE_NAME);
@@ -49,8 +53,16 @@ export async function writeOnboardingReport({
   compatibilityWarnings = [],
   runtimeEnvironment = null,
   operationMode = 'init',
+  tokenOptimization = undefined,
+  memoryContinuity = undefined,
 }) {
   const onboardingReportPath = path.join(targetDirectoryPath, '.agent-context', 'state', 'onboarding-report.json');
+  const resolvedTokenOptimization = typeof tokenOptimization === 'undefined'
+    ? await readTokenOptimizationState(targetDirectoryPath)
+    : tokenOptimization;
+  const resolvedMemoryContinuity = typeof memoryContinuity === 'undefined'
+    ? await readMemoryContinuityState(targetDirectoryPath)
+    : memoryContinuity;
   const onboardingReport = {
     cliVersion: CLI_VERSION,
     generatedAt: new Date().toISOString(),
@@ -72,6 +84,8 @@ export async function writeOnboardingReport({
     selectedSkillDomains,
     compatibilityWarnings,
     runtimeEnvironment,
+    tokenOptimization: resolvedTokenOptimization,
+    memoryContinuity: resolvedMemoryContinuity,
     autoDetection: {
       recommendedStack: projectDetection.recommendedStackFileName,
       recommendedAdditionalStacks: projectDetection.secondaryStackFileNames || [],
@@ -267,6 +281,14 @@ export async function buildCompiledRulesContent({
       `## TOKEN OPTIMIZATION PROFILE\nSource: .agent-context/state/token-optimization.json\n\n${buildTokenOptimizationGuidanceBlock(tokenOptimizationState).trim()}`
     );
   }
+
+  const memoryContinuityState = await readMemoryContinuityState(resolvedTargetDirectoryPath);
+  if (memoryContinuityState?.enabled) {
+    contextBlocks.push(
+      `## MEMORY CONTINUITY PROFILE\nSource: .agent-context/state/memory-continuity.json\n\n${buildMemoryContinuityGuidanceBlock(memoryContinuityState).trim()}`
+    );
+  }
+
   contextBlocks.push(
     [
       '## LAYER 7: STATE AWARENESS (MANDATORY)',

package/lib/cli/memory-continuity.mjs

@@ -0,0 +1,395 @@
+/**
+ * Cross-agent memory continuity utilities.
+ * Provides provider-agnostic observation normalization, privacy redaction,
+ * lightweight indexing, and selective hydration helpers.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { pathExists } from './utils.mjs';
+
+const PRIVATE_BLOCK_PATTERN = /<private>[\s\S]*?<\/private>/gi;
+
+const INLINE_SENSITIVE_PATTERNS = [
+  {
+    reason: 'api-key-like-value',
+    pattern: /\b(api[_-]?key)\b\s*[:=]\s*[^\s,;]+/gi,
+    replacer: (_match, fieldName) => `${fieldName}=[REDACTED]`,
+  },
+  {
+    reason: 'token-like-value',
+    pattern: /\b(token)\b\s*[:=]\s*[^\s,;]+/gi,
+    replacer: (_match, fieldName) => `${fieldName}=[REDACTED]`,
+  },
+  {
+    reason: 'password-like-value',
+    pattern: /\b(password|passwd|pwd)\b\s*[:=]\s*[^\s,;]+/gi,
+    replacer: (_match, fieldName) => `${fieldName}=[REDACTED]`,
+  },
+  {
+    reason: 'bearer-token',
+    pattern: /\bBearer\s+[A-Za-z0-9._-]+/g,
+    replacer: () => 'Bearer [REDACTED]',
+  },
+];
+
+export const MEMORY_SCHEMA_VERSION = '1.0.0';
+export const MEMORY_CONTINUITY_STATE_FILE_NAME = 'memory-continuity.json';
+
+const MEMORY_CONTINUITY_STATE_SCHEMA_VERSION = 'memory-continuity-v1';
+
+export const SUPPORTED_MEMORY_ADAPTER_IDS = Object.freeze([
+  'claude-code',
+  'gemini-cli',
+  'vscode-chat',
+]);
+
+export const SUPPORTED_MEMORY_EVENT_TYPES = Object.freeze([
+  'prompt',
+  'tool-use',
+  'decision',
+  'summary',
+  'issue',
+  'context',
+]);
+
+function toIsoTimestamp(rawValue) {
+  if (typeof rawValue !== 'string' || rawValue.trim().length === 0) {
+    return new Date().toISOString();
+  }
+
+  const parsedDate = new Date(rawValue);
+  if (Number.isNaN(parsedDate.getTime())) {
+    return new Date().toISOString();
+  }
+
+  return parsedDate.toISOString();
+}
+
+function toNonEmptyString(rawValue, fallbackValue = '') {
+  if (typeof rawValue !== 'string') {
+    return fallbackValue;
+  }
+
+  const normalizedValue = rawValue.trim();
+  return normalizedValue.length > 0 ? normalizedValue : fallbackValue;
+}
+
+function normalizeTags(rawTags) {
+  if (!Array.isArray(rawTags)) {
+    return [];
+  }
+
+  const tagSet = new Set();
+  for (const rawTag of rawTags) {
+    const normalizedTag = toNonEmptyString(String(rawTag || '')).toLowerCase();
+    if (normalizedTag) {
+      tagSet.add(normalizedTag);
+    }
+  }
+
+  return Array.from(tagSet);
+}
+
+function normalizeMemoryAdapterIds(rawAdapterIds) {
+  if (!Array.isArray(rawAdapterIds) || rawAdapterIds.length === 0) {
+    return [...SUPPORTED_MEMORY_ADAPTER_IDS];
+  }
+
+  const normalizedAdapterIdSet = new Set();
+  for (const rawAdapterId of rawAdapterIds) {
+    const normalizedAdapterId = toNonEmptyString(String(rawAdapterId || '')).toLowerCase();
+    if (!normalizedAdapterId) {
+      continue;
+    }
+
+    if (!SUPPORTED_MEMORY_ADAPTER_IDS.includes(normalizedAdapterId)) {
+      continue;
+    }
+
+    normalizedAdapterIdSet.add(normalizedAdapterId);
+  }
+
+  if (normalizedAdapterIdSet.size === 0) {
+    return [...SUPPORTED_MEMORY_ADAPTER_IDS];
+  }
+
+  return Array.from(normalizedAdapterIdSet);
+}
+
+export function estimateTokenUsage(rawText = '') {
+  const normalizedText = String(rawText || '');
+  return Math.max(1, Math.ceil(normalizedText.length / 4));
+}
+
+export function redactSensitiveMemoryText(rawText = '') {
+  let normalizedText = String(rawText || '');
+  const redactionReasons = new Set();
+  let privateTagRedactionCount = 0;
+  let inlineRedactionCount = 0;
+
+  normalizedText = normalizedText.replace(PRIVATE_BLOCK_PATTERN, () => {
+    privateTagRedactionCount += 1;
+    redactionReasons.add('private-tag');
+    return '[REDACTED_PRIVATE_BLOCK]';
+  });
+
+  for (const sensitivePattern of INLINE_SENSITIVE_PATTERNS) {
+    normalizedText = normalizedText.replace(sensitivePattern.pattern, (...replacerArguments) => {
+      inlineRedactionCount += 1;
+      redactionReasons.add(sensitivePattern.reason);
+      return sensitivePattern.replacer(...replacerArguments);
+    });
+  }
+
+  return {
+    redactedText: normalizedText,
+    wasRedacted: privateTagRedactionCount > 0 || inlineRedactionCount > 0,
+    privateTagRedactionCount,
+    inlineRedactionCount,
+    redactionReasons: Array.from(redactionReasons),
+  };
+}
+
+export function normalizeMemoryObservation(rawObservation, options = {}) {
+  const fallbackAdapterId = options.fallbackAdapterId || 'unknown-adapter';
+  const observationId = toNonEmptyString(rawObservation?.id, `${fallbackAdapterId}-${Date.now()}`);
+  const adapterId = toNonEmptyString(rawObservation?.adapterId, fallbackAdapterId);
+
+  const eventTypeCandidate = toNonEmptyString(rawObservation?.eventType, 'context').toLowerCase();
+  const eventType = SUPPORTED_MEMORY_EVENT_TYPES.includes(eventTypeCandidate)
+    ? eventTypeCandidate
+    : 'context';
+
+  const rawDetail = toNonEmptyString(rawObservation?.detail, '');
+  const detailRedaction = redactSensitiveMemoryText(rawDetail);
+
+  const rawSummary = toNonEmptyString(rawObservation?.summary, detailRedaction.redactedText.slice(0, 220));
+  const summaryRedaction = redactSensitiveMemoryText(rawSummary);
+
+  const title = toNonEmptyString(rawObservation?.title, `${eventType} from ${adapterId}`);
+  const tags = normalizeTags(rawObservation?.tags);
+
+  return {
+    id: observationId,
+    projectId: toNonEmptyString(rawObservation?.projectId, 'default-project'),
+    sessionId: toNonEmptyString(rawObservation?.sessionId, 'default-session'),
+    adapterId,
+    eventType,
+    timestamp: toIsoTimestamp(rawObservation?.timestamp),
+    title,
+    summary: summaryRedaction.redactedText,
+    detail: detailRedaction.redactedText,
+    tags,
+    privacy: {
+      level: toNonEmptyString(rawObservation?.privacyLevel, 'internal'),
+      redactionApplied: detailRedaction.wasRedacted || summaryRedaction.wasRedacted,
+      redactionReasons: Array.from(new Set([
+        ...detailRedaction.redactionReasons,
+        ...summaryRedaction.redactionReasons,
+      ])),
+      privateTagRedactionCount: detailRedaction.privateTagRedactionCount + summaryRedaction.privateTagRedactionCount,
+      inlineRedactionCount: detailRedaction.inlineRedactionCount + summaryRedaction.inlineRedactionCount,
+    },
+  };
+}
+
+export function scoreObservationRelevance(queryText, normalizedObservation) {
+  const normalizedQuery = toNonEmptyString(queryText, '').toLowerCase();
+  if (!normalizedQuery) {
+    return 0;
+  }
+
+  const queryTerms = normalizedQuery
+    .split(/\s+/)
+    .map((queryTerm) => queryTerm.trim())
+    .filter((queryTerm) => queryTerm.length > 2);
+
+  if (queryTerms.length === 0) {
+    return 0;
+  }
+
+  const searchableContent = [
+    normalizedObservation.title,
+    normalizedObservation.summary,
+    normalizedObservation.detail,
+    normalizedObservation.tags.join(' '),
+    normalizedObservation.eventType,
+    normalizedObservation.adapterId,
+  ].join(' ').toLowerCase();
+
+  let matchCount = 0;
+  for (const queryTerm of queryTerms) {
+    if (searchableContent.includes(queryTerm)) {
+      matchCount += 1;
+    }
+  }
+
+  return Number((matchCount / queryTerms.length).toFixed(4));
+}
+
+export function buildSessionStartIndex(normalizedObservations, options = {}) {
+  const queryText = toNonEmptyString(options.queryText, '');
+  const maxIndexEntries = Number.isFinite(Number(options.limit)) ? Math.max(1, Number(options.limit)) : 8;
+
+  const rankedEntries = normalizedObservations
+    .map((normalizedObservation) => {
+      const relevanceScore = scoreObservationRelevance(queryText, normalizedObservation);
+      const indexLine = `${normalizedObservation.id}|${normalizedObservation.adapterId}|${normalizedObservation.eventType}|${normalizedObservation.title}`;
+      const indexTokenEstimate = estimateTokenUsage(indexLine);
+
+      return {
+        id: normalizedObservation.id,
+        adapterId: normalizedObservation.adapterId,
+        eventType: normalizedObservation.eventType,
+        timestamp: normalizedObservation.timestamp,
+        title: normalizedObservation.title,
+        summarySnippet: normalizedObservation.summary.slice(0, 120),
+        tags: normalizedObservation.tags,
+        relevanceScore,
+        indexTokenEstimate,
+      };
+    })
+    .sort((leftEntry, rightEntry) => {
+      if (rightEntry.relevanceScore !== leftEntry.relevanceScore) {
+        return rightEntry.relevanceScore - leftEntry.relevanceScore;
+      }
+
+      return rightEntry.timestamp.localeCompare(leftEntry.timestamp);
+    });
+
+  const indexEntries = rankedEntries.slice(0, maxIndexEntries);
+  const totalTokenEstimate = indexEntries.reduce(
+    (tokenAccumulator, indexEntry) => tokenAccumulator + indexEntry.indexTokenEstimate,
+    0
+  );
+
+  return {
+    indexEntries,
+    totalTokenEstimate,
+    totalCandidateCount: rankedEntries.length,
+  };
+}
+
+export function hydrateIndexedObservations(indexEntries, normalizedObservations, options = {}) {
+  const fullFetchLimit = Number.isFinite(Number(options.fullFetchLimit))
+    ? Math.max(1, Number(options.fullFetchLimit))
+    : 2;
+
+  const observationLookup = new Map(normalizedObservations.map((normalizedObservation) => [
+    normalizedObservation.id,
+    normalizedObservation,
+  ]));
+
+  const selectedIds = indexEntries.slice(0, fullFetchLimit).map((indexEntry) => indexEntry.id);
+  const hydratedObservations = selectedIds
+    .map((selectedId) => observationLookup.get(selectedId))
+    .filter(Boolean);
+
+  const hydrationTokenEstimate = hydratedObservations.reduce(
+    (tokenAccumulator, hydratedObservation) => tokenAccumulator + estimateTokenUsage(hydratedObservation.detail),
+    0
+  );
+
+  return {
+    selectedIds,
+    hydratedObservations,
+    hydrationTokenEstimate,
+  };
+}
+
+export function createMemoryContinuityState(options = {}) {
+  const isEnabled = options.isEnabled !== false;
+  const sessionStartIndexLimit = Number.isFinite(Number(options.sessionStartIndexLimit))
+    ? Math.max(1, Number(options.sessionStartIndexLimit))
+    : 8;
+  const fullHydrationLimit = Number.isFinite(Number(options.fullHydrationLimit))
+    ? Math.max(1, Number(options.fullHydrationLimit))
+    : 2;
+
+  return {
+    schemaVersion: MEMORY_CONTINUITY_STATE_SCHEMA_VERSION,
+    enabled: isEnabled,
+    hydrationMode: 'progressive-disclosure',
+    adapters: normalizeMemoryAdapterIds(options.adapterIds),
+    retrieval: {
+      sessionStartIndexLimit,
+      fullHydrationLimit,
+    },
+    privacy: {
+      redactPrivateTags: true,
+      redactInlineSensitivePatterns: true,
+    },
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+export async function readMemoryContinuityState(targetDirectoryPath) {
+  const stateFilePath = path.join(
+    targetDirectoryPath,
+    '.agent-context',
+    'state',
+    MEMORY_CONTINUITY_STATE_FILE_NAME
+  );
+
+  if (!(await pathExists(stateFilePath))) {
+    return null;
+  }
+
+  try {
+    const stateContent = await fs.readFile(stateFilePath, 'utf8');
+    const parsedState = JSON.parse(stateContent);
+    if (typeof parsedState.enabled !== 'boolean') {
+      return null;
+    }
+
+    parsedState.adapters = normalizeMemoryAdapterIds(parsedState.adapters);
+    return parsedState;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeMemoryContinuityState(targetDirectoryPath, memoryContinuityState) {
+  const stateDirectoryPath = path.join(targetDirectoryPath, '.agent-context', 'state');
+  const stateFilePath = path.join(stateDirectoryPath, MEMORY_CONTINUITY_STATE_FILE_NAME);
+
+  await fs.mkdir(stateDirectoryPath, { recursive: true });
+  await fs.writeFile(stateFilePath, JSON.stringify(memoryContinuityState, null, 2) + '\n', 'utf8');
+}
+
+export function buildMemoryContinuityGuidanceBlock(memoryContinuityState) {
+  if (!memoryContinuityState?.enabled) {
+    return [
+      'Memory continuity mode is disabled for this repository.',
+      'Use explicit session summaries when handing off context across tools.',
+    ].join('\n');
+  }
+
+  const adapterGuidanceLine = memoryContinuityState.adapters?.length
+    ? `Supported adapters: ${memoryContinuityState.adapters.join(', ')}.`
+    : `Supported adapters: ${SUPPORTED_MEMORY_ADAPTER_IDS.join(', ')}.`;
+
+  const sessionStartIndexLimit = Number.isFinite(Number(memoryContinuityState.retrieval?.sessionStartIndexLimit))
+    ? Number(memoryContinuityState.retrieval.sessionStartIndexLimit)
+    : 8;
+  const fullHydrationLimit = Number.isFinite(Number(memoryContinuityState.retrieval?.fullHydrationLimit))
+    ? Number(memoryContinuityState.retrieval.fullHydrationLimit)
+    : 2;
+
+  return [
+    'Memory continuity mode is enabled.',
+    'Hydration mode: progressive-disclosure.',
+    adapterGuidanceLine,
+    '',
+    'Session-start retrieval policy:',
+    `- Load compact index first (limit: ${sessionStartIndexLimit} entries).`,
+    `- Hydrate full detail only for highest-value entries (limit: ${fullHydrationLimit}).`,
+    '- Always redact sensitive text before persistence (<private> blocks and inline secret-like fields).',
+    '',
+    'Host compatibility scope:',
+    '- Works for local IDE, CLI, and cloud IDE chat hosts that implement the memory adapter contract or MCP retrieval path.',
+    '- Generic web chat sessions without repository tools cannot auto-hydrate runtime memory and should rely on manual summary export/import.',
+  ].join('\n');
+}

package/lib/cli/utils.mjs

@@ -28,7 +28,7 @@ export function printUsage() {
   console.log('');
   console.log('Usage:');
   console.log('  agentic-senior-core launch');
-  console.log('  agentic-senior-core init [target-directory] [--preset <name>] [--profile <beginner|balanced|strict>] [--profile-pack <name>] [--stack <name>] [--blueprint <name>] [--ci <true|false>] [--newbie] [--token-optimize] [--no-token-optimize] [--token-agent <name>] [--scaffold-docs] [--no-scaffold-docs] [--docs-lang <en|id>] [--project-config <path>] [--runtime-env <auto|linux-wsl|linux|windows|macos>]');
+  console.log('  agentic-senior-core init [target-directory] [--preset <name>] [--profile <beginner|balanced|strict>] [--profile-pack <name>] [--stack <name>] [--blueprint <name>] [--ci <true|false>] [--newbie] [--token-optimize] [--no-token-optimize] [--token-agent <name>] [--memory-continuity] [--no-memory-continuity] [--scaffold-docs] [--no-scaffold-docs] [--docs-lang <en|id>] [--project-config <path>] [--runtime-env <auto|linux-wsl|linux|windows|macos>]');
   console.log('  agentic-senior-core upgrade [target-directory] [--dry-run] [--yes] [--mcp-template]');
   console.log('  agentic-senior-core optimize [target-directory] [--agent <copilot|claude|cursor|windsurf|gemini|codex|cline>] [--enable|--disable] [--show]');
   console.log('  agentic-senior-core mcp');
@@ -49,6 +49,8 @@ export function printUsage() {
   console.log('  --token-optimize  Explicitly enable token optimization policy during init (default behavior)');
   console.log('  --token-agent     Set token optimization agent target (copilot, claude, cursor, windsurf, gemini, codex, cline)');
   console.log('  --no-token-optimize  Disable token optimization policy during init');
+  console.log('  --memory-continuity  Explicitly enable cross-session memory continuity policy during init (default behavior)');
+  console.log('  --no-memory-continuity  Disable memory continuity policy during init');
   console.log('  --mcp-template   Create .vscode/mcp.json workspace template (MCP trust/start remains manual in IDE)');
   console.log('  --scaffold-docs  Force project documentation scaffolding (architecture, database, API, flow)');
   console.log('  --no-scaffold-docs  Skip project documentation scaffolding');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryuenn3123/agentic-senior-core",
-  "version": "2.0.26",
+  "version": "2.5.3",
   "type": "module",
   "description": "Force your AI Agent to code like a Staff Engineer, not a Junior.",
   "bin": {
@@ -52,6 +52,7 @@
     "benchmark:writer-judge": "node ./scripts/benchmark-writer-judge-matrix.mjs",
     "benchmark:gate": "node ./scripts/benchmark-gate.mjs",
     "benchmark:intelligence": "node ./scripts/benchmark-intelligence.mjs",
+    "benchmark:continuity": "node ./scripts/memory-continuity-benchmark.mjs",
     "report:quality-trend": "node ./scripts/quality-trend-report.mjs",
     "report:docs-quality-drift": "node ./scripts/docs-quality-drift-report.mjs",
     "report:governance-weekly": "node ./scripts/governance-weekly-report.mjs",