pumuki 6.3.7

package/scripts/adapter-real-session-markdown-snippet-section-lib.ts

@@ -0,0 +1,44 @@
+import type { AdapterRealSessionReportParams } from './adapter-real-session-contract';
+import { renderMarkdownFence } from './adapter-real-session-markdown-snippets-lib';
+
+export const appendAttachedSnippetsSection = (
+  lines: string[],
+  params: AdapterRealSessionReportParams
+): void => {
+  lines.push('## Attached Snippets');
+  lines.push('');
+  lines.push('### hooks.json snippet');
+  lines.push('');
+  lines.push('```json');
+  lines.push(
+    renderMarkdownFence(
+      (params.hookConfigContent ?? '(missing)').split(/\r?\n/).slice(0, 80).join('\n')
+    )
+  );
+  lines.push('```');
+  lines.push('');
+  lines.push(`### ${params.runtimeLogPath ?? '.audit_tmp/cascade-hook-runtime-*.log'}`);
+  lines.push('');
+  lines.push('```text');
+  lines.push(renderMarkdownFence(params.runtimeLogTail));
+  lines.push('```');
+  lines.push('');
+  lines.push(`### ${params.smokeLogPath ?? '.audit_tmp/cascade-hook-smoke-*.log'}`);
+  lines.push('');
+  lines.push('```text');
+  lines.push(renderMarkdownFence(params.smokeLogTail));
+  lines.push('```');
+  lines.push('');
+  lines.push(`### ${params.hookLogPath}`);
+  lines.push('');
+  lines.push('```text');
+  lines.push(renderMarkdownFence(params.hookLogTail));
+  lines.push('```');
+  lines.push('');
+  lines.push(`### ${params.writesLogPath}`);
+  lines.push('');
+  lines.push('```text');
+  lines.push(renderMarkdownFence(params.writesLogTail));
+  lines.push('```');
+  lines.push('');
+};

package/scripts/adapter-real-session-markdown-snippets-lib.ts

@@ -0,0 +1,19 @@
+const markdownFence = (value: string): string => {
+  return value.length > 0 ? value : '(empty)';
+};
+
+export const renderMarkdownFence = (value: string): string => {
+  return markdownFence(value);
+};
+
+export const tailFromContent = (
+  content: string | undefined,
+  lines: number
+): string => {
+  if (!content) {
+    return '(missing)';
+  }
+
+  const rows = content.split(/\r?\n/);
+  return rows.slice(Math.max(rows.length - lines, 0)).join('\n').trimEnd() || '(empty)';
+};

package/scripts/adapter-real-session-markdown-value-formatters-lib.ts

@@ -0,0 +1,10 @@
+type YesNo = 'YES' | 'NO';
+type PassFailUnknown = 'PASS' | 'FAIL' | 'UNKNOWN';
+
+export const toYesNo = (value: boolean): YesNo => {
+  return value ? 'YES' : 'NO';
+};
+
+export const toPassFail = (value: boolean): PassFailUnknown => {
+  return value ? 'PASS' : 'FAIL';
+};

package/scripts/adapter-real-session-report-lib.ts

@@ -0,0 +1,16 @@
+export {
+  DEFAULT_ADAPTER_REAL_SESSION_OPERATOR,
+  DEFAULT_ADAPTER_REAL_SESSION_OUT_FILE,
+  DEFAULT_ADAPTER_REAL_SESSION_TAIL_LINES,
+  DEFAULT_ADAPTER_REAL_SESSION_VERSION,
+  DEFAULT_ADAPTER_STATUS_REPORT_FILE,
+  type AdapterParsedStatusReport,
+  type AdapterRealSessionCliOptions,
+  type AdapterRealSessionReportParams,
+} from './adapter-real-session-contract';
+export {
+  buildAdapterRealSessionReportMarkdown,
+  tailFromContent,
+} from './adapter-real-session-markdown-lib';
+export { parseAdapterRealSessionArgs } from './adapter-real-session-args-lib';
+export { parseAdapterRealSessionStatusReport } from './adapter-real-session-status-parser-lib';

package/scripts/adapter-real-session-status-parser-lib.ts

@@ -0,0 +1,42 @@
+import type { AdapterParsedStatusReport } from './adapter-real-session-contract';
+
+const parseCommandExitCode = (
+  markdown: string,
+  commandLabel: string
+): number | undefined => {
+  const escaped = commandLabel.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const regex = new RegExp(`\\|\\s*${escaped}\\s*\\|[^|]*\\|\\s*([0-9]+)\\s*\\|`);
+  const match = markdown.match(regex);
+  if (!match?.[1]) {
+    return undefined;
+  }
+
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isFinite(parsed) ? parsed : undefined;
+};
+
+export const parseAdapterRealSessionStatusReport = (
+  markdown?: string
+): AdapterParsedStatusReport => {
+  if (!markdown) {
+    return {
+      strictAssessmentPass: false,
+      anyAssessmentPass: false,
+    };
+  }
+
+  const verdict = markdown.match(/- verdict:\s*([^\n]+)/)?.[1]?.trim();
+
+  return {
+    verdict,
+    verifyExitCode: parseCommandExitCode(markdown, 'verify-adapter-hooks-runtime'),
+    strictExitCode: parseCommandExitCode(markdown, 'assess-adapter-hooks-session'),
+    anyExitCode: parseCommandExitCode(markdown, 'assess-adapter-hooks-session:any'),
+    strictAssessmentPass: /assess-adapter-hooks-session[\s\S]*?session-assessment=PASS/.test(
+      markdown
+    ),
+    anyAssessmentPass: /assess-adapter-hooks-session:any[\s\S]*?session-assessment=PASS/.test(
+      markdown
+    ),
+  };
+};

package/scripts/adapter-session-status-args-lib.ts

@@ -0,0 +1,46 @@
+import {
+  DEFAULT_ADAPTER_SESSION_STATUS_OUT_FILE,
+  DEFAULT_ADAPTER_SESSION_STATUS_TAIL_LINES,
+  type AdapterSessionStatusCliOptions,
+} from './adapter-session-status-contract';
+
+export const parseAdapterSessionStatusArgs = (
+  args: ReadonlyArray<string>
+): AdapterSessionStatusCliOptions => {
+  const options: AdapterSessionStatusCliOptions = {
+    outFile: DEFAULT_ADAPTER_SESSION_STATUS_OUT_FILE,
+    tailLines: DEFAULT_ADAPTER_SESSION_STATUS_TAIL_LINES,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--out') {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error('Missing value for --out');
+      }
+      options.outFile = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--tail-lines') {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error('Missing value for --tail-lines');
+      }
+      const parsed = Number.parseInt(value, 10);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Invalid --tail-lines value: ${value}`);
+      }
+      options.tailLines = parsed;
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+};

package/scripts/adapter-session-status-audit-latest-lib.ts

@@ -0,0 +1,22 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const findLatestAuditFile = (params: {
+  directory: string;
+  prefix: string;
+  suffix: string;
+}): string | undefined => {
+  if (!existsSync(params.directory)) {
+    return undefined;
+  }
+
+  const matches = readdirSync(params.directory)
+    .filter((entry) => entry.startsWith(params.prefix) && entry.endsWith(params.suffix))
+    .sort((left, right) => right.localeCompare(left));
+
+  if (matches.length === 0) {
+    return undefined;
+  }
+
+  return join(params.directory, matches[0]);
+};

package/scripts/adapter-session-status-audit-tail-entries-lib.ts

@@ -0,0 +1,78 @@
+import { basename, join, resolve } from 'node:path';
+import type { AdapterSessionStatusTail } from './adapter-session-status-contract';
+import { findLatestAuditFile } from './adapter-session-status-audit-latest-lib';
+import {
+  readTailFile,
+  readTailForHookLog,
+  readTailForWritesLog,
+} from './adapter-session-status-tail-readers-lib';
+
+type ResolvedAuditPaths = {
+  hookLogPath: string;
+  writesLogPath: string;
+  latestRuntime: string;
+  latestSmoke: string;
+};
+
+const resolveAdapterSessionAuditPaths = (params: {
+  repoRoot: string;
+}): ResolvedAuditPaths => {
+  const auditDir = resolve(params.repoRoot, '.audit_tmp');
+
+  return {
+    hookLogPath: resolve(params.repoRoot, '.audit_tmp/cascade-hook.log'),
+    writesLogPath: resolve(params.repoRoot, '.audit_tmp/cascade-writes.log'),
+    latestRuntime:
+      findLatestAuditFile({
+        directory: auditDir,
+        prefix: 'cascade-hook-runtime-',
+        suffix: '.log',
+      }) ?? join(auditDir, 'cascade-hook-runtime-<missing>.log'),
+    latestSmoke:
+      findLatestAuditFile({
+        directory: auditDir,
+        prefix: 'cascade-hook-smoke-',
+        suffix: '.log',
+      }) ?? join(auditDir, 'cascade-hook-smoke-<missing>.log'),
+  };
+};
+
+export const buildAdapterSessionStatusTailEntries = (params: {
+  repoRoot: string;
+  tailLines: number;
+}): ReadonlyArray<AdapterSessionStatusTail> => {
+  const paths = resolveAdapterSessionAuditPaths({
+    repoRoot: params.repoRoot,
+  });
+
+  return [
+    {
+      title: 'cascade-hook.log',
+      path: paths.hookLogPath,
+      content: readTailForHookLog({
+        filePath: paths.hookLogPath,
+        lines: params.tailLines,
+        repoRoot: params.repoRoot,
+      }),
+    },
+    {
+      title: 'cascade-writes.log',
+      path: paths.writesLogPath,
+      content: readTailForWritesLog({
+        filePath: paths.writesLogPath,
+        lines: params.tailLines,
+        repoRoot: params.repoRoot,
+      }),
+    },
+    {
+      title: basename(paths.latestRuntime),
+      path: paths.latestRuntime,
+      content: readTailFile(paths.latestRuntime, params.tailLines),
+    },
+    {
+      title: basename(paths.latestSmoke),
+      path: paths.latestSmoke,
+      content: readTailFile(paths.latestSmoke, params.tailLines),
+    },
+  ];
+};

package/scripts/adapter-session-status-audit-tail-lib.ts

@@ -0,0 +1,15 @@
+import type { AdapterSessionStatusTail } from './adapter-session-status-contract';
+import { findLatestAuditFile } from './adapter-session-status-audit-latest-lib';
+import { buildAdapterSessionStatusTailEntries } from './adapter-session-status-audit-tail-entries-lib';
+
+export { findLatestAuditFile };
+
+export const collectAdapterSessionStatusTails = (params: {
+  repoRoot: string;
+  tailLines: number;
+}): ReadonlyArray<AdapterSessionStatusTail> => {
+  return buildAdapterSessionStatusTailEntries({
+    repoRoot: params.repoRoot,
+    tailLines: params.tailLines,
+  });
+};

package/scripts/adapter-session-status-command-lib.ts

@@ -0,0 +1,49 @@
+import { execFileSync } from 'node:child_process';
+import type {
+  AdapterSessionStatusCommand,
+  AdapterSessionStatusCommandExecution,
+} from './adapter-session-status-contract';
+
+export const runAdapterSessionStatusCommand = (
+  command: AdapterSessionStatusCommand
+): AdapterSessionStatusCommandExecution => {
+  try {
+    const output = execFileSync('bash', ['-lc', command.command], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    return {
+      label: command.label,
+      command: command.command,
+      exitCode: 0,
+      output,
+    };
+  } catch (error) {
+    if (
+      error &&
+      typeof error === 'object' &&
+      'status' in error &&
+      'stdout' in error &&
+      'stderr' in error
+    ) {
+      const status = Number((error as { status?: number }).status ?? 1);
+      const stdout = String((error as { stdout?: string | Buffer }).stdout ?? '');
+      const stderr = String((error as { stderr?: string | Buffer }).stderr ?? '');
+
+      return {
+        label: command.label,
+        command: command.command,
+        exitCode: Number.isFinite(status) ? status : 1,
+        output: `${stdout}${stderr}`.trim(),
+      };
+    }
+
+    throw error;
+  }
+};
+
+export const runAdapterSessionStatusCommands = (
+  commands: ReadonlyArray<AdapterSessionStatusCommand>
+): ReadonlyArray<AdapterSessionStatusCommandExecution> =>
+  commands.map((command) => runAdapterSessionStatusCommand(command));

package/scripts/adapter-session-status-contract.ts

@@ -0,0 +1,55 @@
+export type AdapterSessionStatusCliOptions = {
+  outFile: string;
+  tailLines: number;
+};
+
+export type AdapterSessionStatusCommand = {
+  label: string;
+  command: string;
+};
+
+export type AdapterSessionStatusCommandExecution = {
+  label: string;
+  command: string;
+  exitCode: number;
+  output: string;
+};
+
+export type AdapterSessionStatusTail = {
+  title: string;
+  path: string;
+  content: string;
+};
+
+export type BuildAdapterSessionStatusMarkdownParams = {
+  generatedAtIso: string;
+  options: AdapterSessionStatusCliOptions;
+  commands: ReadonlyArray<AdapterSessionStatusCommandExecution>;
+  verdict: AdapterSessionVerdict;
+  tails: ReadonlyArray<AdapterSessionStatusTail>;
+};
+
+export const DEFAULT_ADAPTER_SESSION_STATUS_OUT_FILE =
+  '.audit-reports/adapter/adapter-session-status.md';
+export const DEFAULT_ADAPTER_SESSION_STATUS_TAIL_LINES = 80;
+
+export const ADAPTER_SESSION_STATUS_COMMANDS: ReadonlyArray<AdapterSessionStatusCommand> = [
+  {
+    label: 'collect-runtime-diagnostics',
+    command:
+      'bash legacy/scripts/hooks-system/infrastructure/cascade-hooks/collect-runtime-diagnostics.sh',
+  },
+  {
+    label: 'verify-adapter-hooks-runtime',
+    command: 'npm run verify:adapter-hooks-runtime',
+  },
+  {
+    label: 'assess-adapter-hooks-session',
+    command: 'npm run assess:adapter-hooks-session',
+  },
+  {
+    label: 'assess-adapter-hooks-session:any',
+    command: 'npm run assess:adapter-hooks-session:any',
+  },
+];
+import type { AdapterSessionVerdict } from './adapter-session-status-lib';

package/scripts/adapter-session-status-hook-log-filter-lib.ts

@@ -0,0 +1,38 @@
+import { isPathInsideRepo } from './adapter-session-status-log-utils-lib';
+
+const extractHookFilePath = (line: string): string | undefined => {
+  const analyzingMatch = line.match(/^\\[[^\\]]+\\]\\s+ANALYZING:\\s+(.+?)\\s+\\(\\d+\\s+edits\\)/);
+  if (analyzingMatch?.[1]) {
+    return analyzingMatch[1];
+  }
+
+  const decisionMatch = line.match(/^\\[[^\\]]+\\]\\s+(?:BLOCKED|ALLOWED):.+\\s+in\\s+(.+)$/);
+  if (decisionMatch?.[1]) {
+    return decisionMatch[1];
+  }
+
+  return undefined;
+};
+
+const isSimulatedLine = (line: string): boolean =>
+  line.includes('__pumuki_simulated__') || line.includes('apps/backend/src/example.ts');
+
+export const filterHookLogLinesForRepo = (params: {
+  content: string;
+  repoRoot: string;
+}): ReadonlyArray<string> => {
+  const allLines = params.content.split(/\r?\n/);
+
+  return allLines.filter((line) => {
+    if (line.trim().length === 0) {
+      return false;
+    }
+
+    const filePath = extractHookFilePath(line);
+    if (filePath && isPathInsideRepo({ repoRoot: params.repoRoot, filePath })) {
+      return true;
+    }
+
+    return isSimulatedLine(line);
+  });
+};

package/scripts/adapter-session-status-lib.ts

@@ -0,0 +1,25 @@
+export type AdapterSessionVerdict = 'PASS' | 'NEEDS_REAL_SESSION' | 'BLOCKED';
+
+const hasSessionPass = (output: string): boolean => {
+  return /session-assessment=PASS/.test(output);
+};
+
+export const determineAdapterSessionVerdict = (params: {
+  verifyExitCode: number;
+  strictOutput: string;
+  anyOutput: string;
+}): AdapterSessionVerdict => {
+  if (params.verifyExitCode !== 0) {
+    return 'BLOCKED';
+  }
+
+  if (hasSessionPass(params.strictOutput)) {
+    return 'PASS';
+  }
+
+  if (hasSessionPass(params.anyOutput)) {
+    return 'NEEDS_REAL_SESSION';
+  }
+
+  return 'BLOCKED';
+};

package/scripts/adapter-session-status-log-filter-lib.ts

@@ -0,0 +1,3 @@
+export { toTailFromText, isPathInsideRepo } from './adapter-session-status-log-utils-lib';
+export { filterHookLogLinesForRepo } from './adapter-session-status-hook-log-filter-lib';
+export { filterWritesLogLinesForRepo } from './adapter-session-status-writes-log-filter-lib';

package/scripts/adapter-session-status-log-utils-lib.ts

@@ -0,0 +1,23 @@
+export const toTailFromText = (text: string, lines: number): string => {
+  const rows = text.split(/\r?\n/);
+  return rows.slice(Math.max(rows.length - lines, 0)).join('\n').trimEnd();
+};
+
+export const isPathInsideRepo = (params: {
+  repoRoot: string;
+  filePath: string;
+}): boolean => {
+  const candidate = params.filePath.trim();
+  if (candidate.length === 0) {
+    return false;
+  }
+
+  if (!candidate.startsWith('/')) {
+    return true;
+  }
+
+  const normalizedRepo = params.repoRoot.endsWith('/')
+    ? params.repoRoot
+    : `${params.repoRoot}/`;
+  return candidate === params.repoRoot || candidate.startsWith(normalizedRepo);
+};

package/scripts/adapter-session-status-markdown-lib.ts

@@ -0,0 +1,65 @@
+import type { BuildAdapterSessionStatusMarkdownParams } from './adapter-session-status-contract';
+
+const markdownEscapeFence = (value: string): string => {
+  return value.length > 0 ? value : '(empty)';
+};
+
+export const buildAdapterSessionStatusMarkdown = (
+  params: BuildAdapterSessionStatusMarkdownParams
+): string => {
+  const lines: string[] = [];
+
+  lines.push('# Adapter Session Status Report');
+  lines.push('');
+  lines.push(`- generated_at: ${params.generatedAtIso}`);
+  lines.push(`- verdict: ${params.verdict}`);
+  lines.push(`- tail_lines: ${params.options.tailLines}`);
+  lines.push('');
+
+  lines.push('## Commands');
+  lines.push('');
+  lines.push('| step | command | exit_code |');
+  lines.push('| --- | --- | --- |');
+  for (const command of params.commands) {
+    lines.push(`| ${command.label} | \`${command.command}\` | ${command.exitCode} |`);
+  }
+  lines.push('');
+
+  lines.push('## Command Output');
+  lines.push('');
+  for (const command of params.commands) {
+    lines.push(`### ${command.label}`);
+    lines.push('');
+    lines.push('```text');
+    lines.push(markdownEscapeFence(command.output.trimEnd()));
+    lines.push('```');
+    lines.push('');
+  }
+
+  lines.push('## Audit Log Tails');
+  lines.push('');
+  for (const tail of params.tails) {
+    lines.push(`### ${tail.title}`);
+    lines.push('');
+    lines.push(`- path: \`${tail.path}\``);
+    lines.push('```text');
+    lines.push(markdownEscapeFence(tail.content));
+    lines.push('```');
+    lines.push('');
+  }
+
+  lines.push('## Interpretation');
+  lines.push('');
+  if (params.verdict === 'PASS') {
+    lines.push('- Real Adapter pre/post events are present in strict session assessment.');
+  } else if (params.verdict === 'NEEDS_REAL_SESSION') {
+    lines.push('- Runtime wiring appears healthy, but strict assessment did not observe real IDE events yet.');
+    lines.push('- Next: execute a real Adapter write session and regenerate this report.');
+  } else {
+    lines.push('- Runtime verification and/or session assessments are failing.');
+    lines.push('- Next: run `npm run install:adapter-hooks-config` and `npm run verify:adapter-hooks-runtime`, then retry.');
+  }
+  lines.push('');
+
+  return `${lines.join('\n')}\n`;
+};

package/scripts/adapter-session-status-report-lib.ts

@@ -0,0 +1,21 @@
+export {
+  ADAPTER_SESSION_STATUS_COMMANDS,
+  DEFAULT_ADAPTER_SESSION_STATUS_OUT_FILE,
+  DEFAULT_ADAPTER_SESSION_STATUS_TAIL_LINES,
+  type AdapterSessionStatusCliOptions,
+  type AdapterSessionStatusCommand,
+  type AdapterSessionStatusCommandExecution,
+  type AdapterSessionStatusTail,
+} from './adapter-session-status-contract';
+export {
+  filterHookLogLinesForRepo,
+  filterWritesLogLinesForRepo,
+  isPathInsideRepo,
+  toTailFromText,
+} from './adapter-session-status-log-filter-lib';
+export { parseAdapterSessionStatusArgs } from './adapter-session-status-args-lib';
+export {
+  deriveAdapterSessionVerdictFromCommands,
+  exitCodeForAdapterSessionVerdict,
+} from './adapter-session-status-verdict-lib';
+export { buildAdapterSessionStatusMarkdown } from './adapter-session-status-markdown-lib';

package/scripts/adapter-session-status-tail-readers-lib.ts

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync } from 'node:fs';
+import {
+  filterHookLogLinesForRepo,
+  filterWritesLogLinesForRepo,
+  toTailFromText,
+} from './adapter-session-status-log-filter-lib';
+
+export const readTailFile = (filePath: string, lines: number): string => {
+  if (!existsSync(filePath)) {
+    return `[missing] ${filePath}`;
+  }
+
+  return toTailFromText(readFileSync(filePath, 'utf8'), lines);
+};
+
+const readTailForFilteredLog = (params: {
+  filePath: string;
+  lines: number;
+  repoRoot: string;
+  filter: (input: { content: string; repoRoot: string }) => ReadonlyArray<string>;
+}): string => {
+  if (!existsSync(params.filePath)) {
+    return `[missing] ${params.filePath}`;
+  }
+
+  const filtered = params.filter({
+    content: readFileSync(params.filePath, 'utf8'),
+    repoRoot: params.repoRoot,
+  });
+
+  if (filtered.length === 0) {
+    return `[no entries matched repoRoot=${params.repoRoot}]`;
+  }
+
+  return filtered.slice(Math.max(filtered.length - params.lines, 0)).join('\n').trimEnd();
+};
+
+export const readTailForHookLog = (params: {
+  filePath: string;
+  lines: number;
+  repoRoot: string;
+}): string => {
+  return readTailForFilteredLog({
+    ...params,
+    filter: filterHookLogLinesForRepo,
+  });
+};
+
+export const readTailForWritesLog = (params: {
+  filePath: string;
+  lines: number;
+  repoRoot: string;
+}): string => {
+  return readTailForFilteredLog({
+    ...params,
+    filter: filterWritesLogLinesForRepo,
+  });
+};