@ryuenn3123/agentic-senior-core 4.1.0 → 4.2.0

package/lib/cli/ascx/runtime.mjs

@@ -0,0 +1,188 @@
+import { spawn } from 'node:child_process';
+
+import { compressGitDiffOutput } from './adapters/git-diff.mjs';
+import { compressGitStatusOutput } from './adapters/git-status.mjs';
+import { compressNpmTestOutput } from './adapters/npm-test.mjs';
+import { buildAscxFooter, shouldWriteSafetyTee } from './formatter.mjs';
+import { classifyAscxInvocation, parseAscxCommand } from './lexer.mjs';
+import { writeRawTeeFile } from './tee-writer.mjs';
+
+const ADAPTERS = {
+  'git-diff': compressGitDiffOutput,
+  'git-status': compressGitStatusOutput,
+  'npm-test': compressNpmTestOutput,
+};
+
+function buildCommandEnvironment(baseEnvironment, parsedCommand) {
+  const commandEnvironment = { ...baseEnvironment };
+
+  for (const assignment of parsedCommand.environment) {
+    const separatorIndex = assignment.indexOf('=');
+    const variableName = assignment.slice(0, separatorIndex);
+    const variableValue = assignment.slice(separatorIndex + 1);
+
+    commandEnvironment[variableName] = variableValue;
+  }
+
+  return commandEnvironment;
+}
+
+function runSpawnedCommand(parsedCommand, options = {}) {
+  const {
+    cwd = process.cwd(),
+    env = process.env,
+    shell = false,
+  } = options;
+
+  return new Promise((resolve) => {
+    const useWindowsNpmShell = process.platform === 'win32'
+      && parsedCommand.executable === 'npm'
+      && shell === false;
+    const executable = shell
+      ? parsedCommand.commandText
+      : parsedCommand.executable;
+    const args = shell ? [] : parsedCommand.args;
+    const childProcess = spawn(executable, args, {
+      cwd,
+      env: buildCommandEnvironment(env, parsedCommand),
+      shell: shell || useWindowsNpmShell,
+      windowsHide: true,
+    });
+    let stdout = '';
+    let stderr = '';
+
+    childProcess.stdout?.setEncoding('utf8');
+    childProcess.stderr?.setEncoding('utf8');
+    childProcess.stdout?.on('data', (chunk) => {
+      stdout += chunk;
+    });
+    childProcess.stderr?.on('data', (chunk) => {
+      stderr += chunk;
+    });
+    childProcess.on('error', (error) => {
+      stderr += `${error.name}: ${error.message}\n`;
+    });
+    childProcess.on('close', (exitCode) => {
+      resolve({
+        stdout,
+        stderr,
+        exitCode: typeof exitCode === 'number' ? exitCode : 1,
+      });
+    });
+  });
+}
+
+function combineOutput(stdout, stderr) {
+  return [stdout, stderr].filter(Boolean).join('\n');
+}
+
+async function formatCompressedResult({
+  adapterResult,
+  capture,
+  classification,
+  commandText,
+  cwd,
+  teeDirectoryPath,
+}) {
+  const rawOutput = combineOutput(capture.stdout, capture.stderr);
+  const preliminaryFooter = buildAscxFooter({
+    classification: classification.kind,
+    commandText,
+    compactOutput: adapterResult.output,
+    exitCode: capture.exitCode,
+    filterName: adapterResult.filterName,
+    rawOutput,
+    rawTeePath: null,
+  });
+  const rawTeePath = shouldWriteSafetyTee({
+    adapterResult,
+    exitCode: capture.exitCode,
+    reductionPercent: preliminaryFooter.reductionPercent,
+  })
+    ? await writeRawTeeFile({
+      commandText,
+      cwd,
+      exitCode: capture.exitCode,
+      rawOutput,
+      teeDirectoryPath,
+    })
+    : null;
+  const footer = buildAscxFooter({
+    classification: classification.kind,
+    commandText,
+    compactOutput: adapterResult.output,
+    exitCode: capture.exitCode,
+    filterName: adapterResult.filterName,
+    rawOutput,
+    rawTeePath,
+  });
+
+  return {
+    stdout: `${adapterResult.output}\n\n${footer.text}\n`,
+    stderr: '',
+    exitCode: capture.exitCode,
+    compressed: adapterResult.confident === true,
+    rawTeePath,
+    footer,
+    adapterResult,
+  };
+}
+
+export async function runAscx(commandArguments, options = {}) {
+  const {
+    cwd = process.cwd(),
+    executeCommand = runSpawnedCommand,
+    teeDirectoryPath,
+  } = options;
+  const parsedCommand = parseAscxCommand(commandArguments);
+  const classification = classifyAscxInvocation(parsedCommand);
+
+  if (!parsedCommand.executable) {
+    return {
+      stdout: '',
+      stderr: 'ascx: command is required\n',
+      exitCode: 1,
+      parsedCommand,
+      classification,
+      compressed: false,
+      rawTeePath: null,
+    };
+  }
+
+  const capture = await executeCommand(parsedCommand, {
+    cwd,
+    shell: classification.kind === 'unsafe-for-compression',
+  });
+
+  if (classification.kind !== 'compressible') {
+    return {
+      stdout: capture.stdout,
+      stderr: capture.stderr,
+      exitCode: capture.exitCode,
+      parsedCommand,
+      classification,
+      compressed: false,
+      rawTeePath: null,
+    };
+  }
+
+  const adapter = ADAPTERS[classification.adapterName];
+  const adapterResult = adapter({
+    stdout: capture.stdout,
+    stderr: capture.stderr,
+    exitCode: capture.exitCode,
+  });
+
+  return {
+    ...await formatCompressedResult({
+      adapterResult,
+      capture,
+      classification,
+      commandText: parsedCommand.commandText,
+      cwd,
+      teeDirectoryPath,
+    }),
+    parsedCommand,
+    classification,
+  };
+}

package/lib/cli/ascx/tee-writer.mjs

@@ -0,0 +1,38 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+function sanitizeFileNamePart(rawValue) {
+  return String(rawValue || 'command')
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60) || 'command';
+}
+
+export function getDefaultTeeDirectory(cwd = process.cwd()) {
+  return path.resolve(cwd, '.agent-context', 'state', 'token-saver', 'tee');
+}
+
+export async function writeRawTeeFile({
+  commandText,
+  cwd = process.cwd(),
+  exitCode,
+  rawOutput,
+  teeDirectoryPath = getDefaultTeeDirectory(cwd),
+}) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const commandName = sanitizeFileNamePart(commandText);
+  const teeFilePath = path.resolve(teeDirectoryPath, `${timestamp}-${commandName}.log`);
+  const fileContent = [
+    `[ascx raw output]`,
+    `command: ${commandText}`,
+    `exit: ${exitCode}`,
+    '',
+    rawOutput,
+  ].join('\n');
+
+  await fs.mkdir(path.dirname(teeFilePath), { recursive: true });
+  await fs.writeFile(teeFilePath, fileContent, 'utf8');
+
+  return teeFilePath;
+}

package/lib/cli/ascx/token-estimate.mjs

@@ -0,0 +1,15 @@
+export const ASCX_TOKEN_ESTIMATE_METHOD = 'chars-div-4-local-estimate';
+
+export function estimateOutputTokens(outputText) {
+  const textLength = String(outputText || '').length;
+  return Math.max(0, Math.ceil(textLength / 4));
+}
+
+export function calculateReductionPercent(rawTokens, compactTokens) {
+  if (rawTokens <= 0) {
+    return 0;
+  }
+
+  const reducedTokens = Math.max(0, rawTokens - compactTokens);
+  return Number(((reducedTokens / rawTokens) * 100).toFixed(2));
+}

package/lib/cli/commands/context.mjs

@@ -0,0 +1,140 @@
+import { stdin } from 'node:process';
+
+import { buildSelectedContextManifest } from '../adaptive-context.mjs';
+
+export function parseContextArguments(commandArguments) {
+  const parsedOptions = {
+    requestId: 'adhoc-request',
+    requestText: '',
+    contextFiles: [],
+    json: false,
+    readStdin: false,
+  };
+  const requestParts = [];
+
+  for (let argumentIndex = 0; argumentIndex < commandArguments.length; argumentIndex++) {
+    const currentArgument = commandArguments[argumentIndex];
+
+    if (currentArgument === '--json') {
+      parsedOptions.json = true;
+      continue;
+    }
+
+    if (currentArgument === '--stdin') {
+      parsedOptions.readStdin = true;
+      continue;
+    }
+
+    if (currentArgument === '--file') {
+      const contextFilePath = commandArguments[argumentIndex + 1];
+      if (!contextFilePath || contextFilePath.startsWith('--')) {
+        throw new Error('Missing value for --file');
+      }
+
+      parsedOptions.contextFiles.push(contextFilePath);
+      argumentIndex++;
+      continue;
+    }
+
+    if (currentArgument === '--files') {
+      const contextFileList = commandArguments[argumentIndex + 1];
+      if (!contextFileList || contextFileList.startsWith('--')) {
+        throw new Error('Missing value for --files');
+      }
+
+      parsedOptions.contextFiles.push(
+        ...contextFileList
+          .split(',')
+          .map((contextFilePath) => contextFilePath.trim())
+          .filter(Boolean)
+      );
+      argumentIndex++;
+      continue;
+    }
+
+    if (currentArgument === '--request-id') {
+      const requestId = commandArguments[argumentIndex + 1];
+      if (!requestId || requestId.startsWith('--')) {
+        throw new Error('Missing value for --request-id');
+      }
+
+      parsedOptions.requestId = requestId;
+      argumentIndex++;
+      continue;
+    }
+
+    if (currentArgument.startsWith('--')) {
+      throw new Error(`Unknown option: ${currentArgument}`);
+    }
+
+    requestParts.push(currentArgument);
+  }
+
+  parsedOptions.requestText = requestParts.join(' ').trim();
+  return parsedOptions;
+}
+
+function readRequestFromStdin() {
+  return new Promise((resolve, reject) => {
+    let requestText = '';
+
+    stdin.setEncoding('utf8');
+    stdin.on('data', (chunk) => {
+      requestText += chunk;
+    });
+    stdin.on('error', reject);
+    stdin.on('end', () => {
+      resolve(requestText.trim());
+    });
+  });
+}
+
+function formatList(label, values) {
+  if (values.length === 0) {
+    return [`${label}: none`];
+  }
+
+  return [
+    `${label}:`,
+    ...values.map((value) => `- ${value}`),
+  ];
+}
+
+function formatManifestText(manifest) {
+  return [
+    'Adaptive Context',
+    `requestId: ${manifest.requestId}`,
+    `labels: ${manifest.labels.length > 0 ? manifest.labels.join(', ') : 'none'}`,
+    `uncertainty: ${manifest.uncertainty}`,
+    `budget: ${manifest.budget.status} (${manifest.budget.selectedRuleCount}/${manifest.budget.maxRecommendedRuleCount} recommended rules)`,
+    `fallbackRequired: ${manifest.fallbackRequired}`,
+    ...formatList('contextFiles', manifest.contextFiles),
+    ...formatList('selectedRules', manifest.selectedRules),
+    ...formatList('selectedPrompts', manifest.selectedPrompts),
+    ...formatList('selectedDocs', manifest.selectedDocs),
+  ].join('\n');
+}
+
+export async function runContextCommand(commandArguments) {
+  const contextOptions = parseContextArguments(commandArguments);
+  const requestText = contextOptions.readStdin
+    ? await readRequestFromStdin()
+    : contextOptions.requestText;
+
+  if (!requestText) {
+    throw new Error('Context request text is required. Pass text as arguments or use --stdin.');
+  }
+
+  const manifest = buildSelectedContextManifest({
+    contextFiles: contextOptions.contextFiles,
+    requestId: contextOptions.requestId,
+    requestText,
+  });
+
+  if (contextOptions.json) {
+    console.log(JSON.stringify(manifest, null, 2));
+    return;
+  }
+
+  console.log(formatManifestText(manifest));
+}

package/lib/cli/commands/init.mjs

@@ -565,6 +565,7 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
     console.log(`- Review thresholds: ${formatBlockingSeverities(selectedPolicyProfile.blockingSeverities)}`);
     console.log(`- Setup time: ${formatDuration(setupDurationMs)}`);
     console.log('- Generated files: AGENTS.md, CLAUDE.md, GEMINI.md, .agent-context/, and .agent-context/state/onboarding-report.json');
+    console.log('- Default response mode: Compact Natural Mode enabled (.agent-context/prompts/compact-natural-mode.md)');
     if (scaffoldingResult?.bootstrapMode === 'ai-synthesis') {
       console.log(`- Bootstrap prompts: ${(scaffoldingResult.generatedPromptFileNames || []).length} files generated in .agent-context/prompts/`);
       if ((scaffoldingResult.materializedFileNames || []).length > 0) {
@@ -587,7 +588,7 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
       console.log('- Memory continuity policy: disabled (--no-memory-continuity)');
     }
     if (isTokenOptimizationEnabled) {
-      console.log(`- Token optimization policy: enabled for ${selectedTokenAgentName}`);
+      console.log(`- Token optimization policy: enabled for ${selectedTokenAgentName} (ASCX command guidance on)`);
     } else {
       console.log('- Token optimization policy: disabled (--no-token-optimize)');
     }

package/lib/cli/commands/optimize.mjs

@@ -7,6 +7,11 @@ import {
   TOKEN_OPTIMIZATION_REPORT_FILE_NAME,
   normalizeAgentName,
   detectRtkBinary,
+  detectAscxRuntime,
+  checkAscxTeeReadiness,
+  resolveRuntimeTokenSaverMode,
+  buildRuntimeTokenSaverWarnings,
+  buildRuntimeTokenSaverNextAction,
   buildRtkInstallHint,
   buildRtkHookCommand,
   createTokenOptimizationState,
@@ -19,12 +24,43 @@ export function parseOptimizeArguments(commandArguments) {
     targetDirectory: '.',
     agent: 'copilot',
     enabled: true,
+    mode: 'configure',
     show: false,
   };
 
+  function setOptimizeMode(nextMode) {
+    if (parsedOptimizeOptions.mode !== 'configure' && parsedOptimizeOptions.mode !== nextMode) {
+      throw new Error(`Conflicting optimize modes: ${parsedOptimizeOptions.mode} and ${nextMode}`);
+    }
+
+    parsedOptimizeOptions.mode = nextMode;
+  }
+
   for (let argumentIndex = 0; argumentIndex < commandArguments.length; argumentIndex++) {
     const currentArgument = commandArguments[argumentIndex];
 
+    if (currentArgument === 'install') {
+      setOptimizeMode('install');
+      parsedOptimizeOptions.enabled = true;
+      continue;
+    }
+
+    if (currentArgument === 'off') {
+      setOptimizeMode('off');
+      parsedOptimizeOptions.enabled = false;
+      continue;
+    }
+
+    if (currentArgument === 'status') {
+      setOptimizeMode('status');
+      continue;
+    }
+
+    if (currentArgument === 'doctor') {
+      setOptimizeMode('doctor');
+      continue;
+    }
+
     if (!currentArgument.startsWith('--')) {
       parsedOptimizeOptions.targetDirectory = currentArgument;
       continue;
@@ -43,19 +79,36 @@ export function parseOptimizeArguments(commandArguments) {
 
     if (currentArgument === '--enable') {
       parsedOptimizeOptions.enabled = true;
+      if (parsedOptimizeOptions.mode === 'off') {
+        setOptimizeMode('install');
+      }
       continue;
     }
 
     if (currentArgument === '--disable') {
       parsedOptimizeOptions.enabled = false;
+      if (parsedOptimizeOptions.mode === 'install') {
+        setOptimizeMode('off');
+      }
       continue;
     }
 
     if (currentArgument === '--show') {
+      setOptimizeMode('show');
       parsedOptimizeOptions.show = true;
       continue;
     }
 
+    if (currentArgument === '--status') {
+      setOptimizeMode('status');
+      continue;
+    }
+
+    if (currentArgument === '--doctor') {
+      setOptimizeMode('doctor');
+      continue;
+    }
+
     throw new Error(`Unknown option: ${currentArgument}`);
   }
 
@@ -63,6 +116,78 @@ export function parseOptimizeArguments(commandArguments) {
   return parsedOptimizeOptions;
 }
 
+function formatStatusLine(label, value) {
+  return `${label}: ${value}`;
+}
+
+async function buildRuntimeTokenSaverStatus(resolvedTargetDirectoryPath, options = {}) {
+  const onboardingReport = await loadOnboardingReportIfExists(resolvedTargetDirectoryPath);
+  const existingOptimizationState = await readTokenOptimizationState(resolvedTargetDirectoryPath);
+  const ascxDetection = detectAscxRuntime();
+  const rtkDetection = detectRtkBinary();
+  const teeReadiness = await checkAscxTeeReadiness(resolvedTargetDirectoryPath, {
+    writeProbe: options.writeProbe === true,
+  });
+  const mode = resolveRuntimeTokenSaverMode({
+    tokenOptimizationState: existingOptimizationState,
+    ascxDetection,
+    rtkDetection,
+  });
+  const warnings = buildRuntimeTokenSaverWarnings({
+    mode,
+    onboardingReport,
+    ascxDetection,
+    teeReadiness,
+    rtkDetection,
+  });
+
+  return {
+    targetDirectory: resolvedTargetDirectoryPath,
+    initialized: Boolean(onboardingReport),
+    mode,
+    ascx: ascxDetection,
+    tee: teeReadiness,
+    rtk: rtkDetection,
+    nineRouter: {
+      status: 'not-checked',
+      reason: 'localhost probing is intentionally deferred',
+    },
+    warnings,
+    nextAction: buildRuntimeTokenSaverNextAction({ mode, warnings }),
+    tokenOptimizationState: existingOptimizationState,
+  };
+}
+
+function printRuntimeTokenSaverStatus(statusReport, options = {}) {
+  const title = options.title || 'Runtime token saver status';
+  const ascxStatus = statusReport.ascx.isAvailable
+    ? `found (${statusReport.ascx.source})`
+    : 'missing';
+  const rtkStatus = statusReport.rtk.isAvailable
+    ? `detected${statusReport.rtk.version ? ` (${statusReport.rtk.version})` : ''}`
+    : 'not-detected';
+
+  console.log(title);
+  console.log(formatStatusLine('target', statusReport.targetDirectory));
+  console.log(formatStatusLine('initialized', statusReport.initialized ? 'yes' : 'no'));
+  console.log(formatStatusLine('mode', statusReport.mode));
+  console.log(formatStatusLine('ascx', ascxStatus));
+  console.log(formatStatusLine('tee', `${statusReport.tee.status} (${statusReport.tee.path})`));
+  console.log(formatStatusLine('rtk', rtkStatus));
+  console.log(formatStatusLine('9router', statusReport.nineRouter.status));
+
+  if (statusReport.warnings.length > 0) {
+    console.log('warnings:');
+    for (const warning of statusReport.warnings) {
+      console.log(`- ${warning}`);
+    }
+  } else {
+    console.log('warnings: none');
+  }
+
+  console.log(formatStatusLine('next_action', statusReport.nextAction));
+}
+
 export async function runOptimizeCommand(targetDirectoryArgument, optimizeOptions = {}) {
   const optimizationStartedAt = Date.now();
   const resolvedTargetDirectoryPath = path.resolve(targetDirectoryArgument || '.');
@@ -72,7 +197,23 @@ export async function runOptimizeCommand(targetDirectoryArgument, optimizeOption
   const selectedAgentName = normalizeAgentName(optimizeOptions.agent || 'copilot');
   const rtkDetection = detectRtkBinary();
 
-  if (optimizeOptions.show) {
+  if (optimizeOptions.mode === 'status') {
+    const statusReport = await buildRuntimeTokenSaverStatus(resolvedTargetDirectoryPath);
+    printRuntimeTokenSaverStatus(statusReport);
+    return;
+  }
+
+  if (optimizeOptions.mode === 'doctor') {
+    const statusReport = await buildRuntimeTokenSaverStatus(resolvedTargetDirectoryPath, {
+      writeProbe: true,
+    });
+    printRuntimeTokenSaverStatus(statusReport, {
+      title: 'ASCX runtime token saver doctor',
+    });
+    return;
+  }
+
+  if (optimizeOptions.show || optimizeOptions.mode === 'show') {
     const existingOptimizationState = await readTokenOptimizationState(resolvedTargetDirectoryPath);
     console.log(
       JSON.stringify(
@@ -97,7 +238,7 @@ export async function runOptimizeCommand(targetDirectoryArgument, optimizeOption
   }
 
   const tokenOptimizationState = createTokenOptimizationState({
-    isEnabled: optimizeOptions.enabled,
+    isEnabled: optimizeOptions.mode === 'off' ? false : optimizeOptions.enabled,
     selectedAgentName,
     rtkDetection,
   });

package/lib/cli/commands/upgrade.mjs

@@ -302,6 +302,7 @@ export async function runUpgradeCommand(targetDirectoryArgument, upgradeOptions
     }
     console.log(`- CI/CD quality checks (guardrails): ${includeCiGuardrails ? 'enabled' : 'disabled'}`);
     console.log('- Instruction surface: AGENTS.md canonical with CLAUDE.md and GEMINI.md import bridges');
+    console.log('- Default response mode: Compact Natural Mode enabled');
     console.log(`- Managed surface stale files: ${managedSurfacePlan.staleFiles.length}`);
     console.log(`- Managed surface stale directories: ${managedSurfacePlan.staleDirectories.length}`);
     console.log(`- Managed surface sync mode: 1:1 (prune enabled)`);
@@ -464,6 +465,7 @@ export async function runUpgradeCommand(targetDirectoryArgument, upgradeOptions
       }
 
       console.log('\nRefreshed files: AGENTS.md, CLAUDE.md, GEMINI.md, .agent-context/, and .agent-context/state/onboarding-report.json');
+      console.log('Default response mode remains Compact Natural Mode through .agent-context/prompts/compact-natural-mode.md.');
       console.log('\nNext-step suggestion (UI scope): run `npx @ryuenn3123/agentic-senior-core audit:design-anti-repeat` to scan CSS, SCSS, SASS, LESS, Tailwind config, and design-token files in this project for typography or palette values that match the anti-repeat ledger in docs/design-intent.json. Add it to your CI alongside `npm test` once the design dossier is populated.');
     } catch (error) {
       console.error('\n[FATAL] An error occurred during upgrade. Attempting automatic rollback...');

package/lib/cli/compiler.mjs

@@ -202,6 +202,14 @@ export async function writeOnboardingReport({
     containerizationStrategy: buildContainerizationStrategySnapshot(dockerStrategy),
     tokenOptimization: resolvedTokenOptimization,
     memoryContinuity: resolvedMemoryContinuity,
+    responseCompression: {
+      enabled: true,
+      mode: 'compact-natural-mode',
+      defaultOn: true,
+      promptFile: '.agent-context/prompts/compact-natural-mode.md',
+      appliesTo: 'agent-final-responses',
+      commandOutputBoundary: 'ASCX handles command-output compression separately',
+    },
     autoDetection: {
       detectedStack: projectDetection.detectedStackFileName,
       detectedAdditionalStacks: projectDetection.secondaryStackFileNames || [],
@@ -383,6 +391,7 @@ export async function buildCompiledRulesContent({
     [
       '## LAYER 5: EXECUTION PROMPTS AND UI TRIGGERS',
       'Load these prompt contracts only when their trigger matches the user request:',
+      'Default. .agent-context/prompts/compact-natural-mode.md -> final response shape and evidence-preserving compact prose',
       '0. Documentation-first mode -> docs, documentation, dokumen, docs/*, architecture docs, flow docs, API docs, lengkapkan docs',
       '1. .agent-context/prompts/init-project.md -> create, build, new project, scaffold',
       '2. .agent-context/prompts/refactor.md -> refactor, improve, clean up, fix',