sandoichi 0.6.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sandoichi",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Bound repeated tool-output context in Claude Code and Codex with deterministic local routing and provider accounting.",
   "license": "MIT",
   "author": "yuzushi",

package/src/artifact-lifecycle.mjs

@@ -4,6 +4,23 @@ import path from 'node:path';
 export const DEFAULT_ARTIFACT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 export const DEFAULT_ARTIFACT_MAX_BYTES = 64 * 1024 * 1024;
 
+export function reuseArtifact(destination, expectedContent) {
+  const { O_NOFOLLOW, O_NONBLOCK } = fs.constants;
+  if (!Number.isInteger(O_NOFOLLOW) || !Number.isInteger(O_NONBLOCK)) {
+    throw new Error('artifact storage requires no-follow open support');
+  }
+  const flags = fs.constants.O_RDONLY | O_NOFOLLOW | O_NONBLOCK;
+  const handle = fs.openSync(destination, flags);
+  try {
+    const stat = fs.fstatSync(handle);
+    if (!stat.isFile() || stat.nlink !== 1) throw new Error('artifact file is unsafe');
+    if (fs.readFileSync(handle, 'utf8') !== expectedContent) throw new Error('artifact content differs');
+    fs.fchmodSync(handle, 0o600);
+  } finally {
+    fs.closeSync(handle);
+  }
+}
+
 function validNumber(value, name) {
   if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${name} is invalid`);
   return value;

package/src/history-archive.mjs

@@ -2,6 +2,8 @@ import { createHash, randomUUID } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { reuseArtifact } from './artifact-lifecycle.mjs';
+
 const MAX_ARTIFACT_BYTES = 16 * 1024 * 1024;
 const MAX_ARCHIVE_BYTES = 64 * 1024 * 1024;
 
@@ -70,11 +72,11 @@ export function persistHistoryArtifact(artifact) {
     fs.writeFileSync(temporary, artifact.content, { flag: 'wx', mode: 0o600 });
     try { fs.linkSync(temporary, destination); }
     catch (error) {
-      if (error?.code !== 'EEXIST' || fs.readFileSync(destination, 'utf8') !== artifact.content) throw error;
+      if (error?.code !== 'EEXIST') throw error;
+      reuseArtifact(destination, artifact.content);
     }
   } finally {
     fs.rmSync(temporary, { force: true });
   }
-  fs.chmodSync(destination, 0o600);
   return artifact;
 }

package/src/hook-cli.mjs

@@ -3,7 +3,7 @@ import { randomUUID } from 'node:crypto';
 import path from 'node:path';
 
 import { createReceipt, normalizeEvent, normalizePolicy, optimizeToolOutput } from './core.mjs';
-import { cleanupArtifacts } from './artifact-lifecycle.mjs';
+import { cleanupArtifacts, reuseArtifact } from './artifact-lifecycle.mjs';
 import { loadProjectRedactionProfile } from './redaction-config.mjs';
 import { defaultMetricsPath, recordMetrics } from './metrics.mjs';
 import {
@@ -86,12 +86,12 @@ function artifactPath(cwd, artifact) {
     fs.writeFileSync(temporary, artifact.content, { flag: 'wx', mode: 0o600 });
     try { fs.linkSync(temporary, destination); }
     catch (error) {
-      if (error?.code !== 'EEXIST' || fs.readFileSync(destination, 'utf8') !== artifact.content) throw error;
+      if (error?.code !== 'EEXIST') throw error;
+      reuseArtifact(destination, artifact.content);
     }
   } finally {
     fs.rmSync(temporary, { force: true });
   }
-  fs.chmodSync(destination, 0o600);
   cleanupArtifacts(directory, { preserveName: name });
   if (!artifactPresent(destination)) throw new Error('artifact storage limit removed the new artifact');
   return path.posix.join('.sando/sando', 'artifacts', name);

package/src/redaction-profile.mjs

@@ -2,10 +2,6 @@ import { createHash } from 'node:crypto';
 
 const BUILT_IN_MATCHERS = Object.freeze([
   [/-----BEGIN [A-Z ]+ KEY-----[\s\S]*?-----END [A-Z ]+ KEY-----/g, '[REDACTED PRIVATE KEY]'],
-  [/(authorization\s*[:=]\s*(?!(?:bearer\s+)?\[REDACTED(?: (?:PRIVATE KEY|TOKEN))?\](?=$|[\s,"'}]))(?:bearer\s+)?)[^\s,"'}]+/gi,
-    (_match, prefix) => `${prefix}[REDACTED]`],
-  [/(["']?(?:api[_-]?key|access[_-]?token|password|secret|private[_-]?key)["']?\s*[:=]\s*["']?)(?!\[REDACTED(?: (?:PRIVATE KEY|TOKEN))?\](?=$|[\s,"'}]))[^\s,"'}]+/gi,
-    (_match, prefix) => `${prefix}[REDACTED]`],
   [/\b(?:sk|rk)-[A-Za-z0-9_-]{12,}\b/g, '[REDACTED TOKEN]'],
   [/\bgh[pousr]_[A-Za-z0-9_-]{12,}\b/g, '[REDACTED TOKEN]'],
   [/\bgithub_pat_[A-Za-z0-9_-]{20,}\b/g, '[REDACTED TOKEN]'],
@@ -20,6 +16,55 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+const REDACTION_WORD = 'REDACTED';
+const REDACTION_PLACEHOLDER = `[${REDACTION_WORD}]`;
+const REDACTION_VALUE = String.raw`\[${REDACTION_WORD}(?: (?:PRIVATE KEY|TOKEN))?\]`;
+const ASSIGNMENT_VALUE = String.raw`${REDACTION_VALUE}(?=$|[\s,"'}])|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\\n])*(?=\n|$)|'(?:\\.|[^'\\\n])*(?=\n|$)|[^\s,"'}]+`;
+
+function isRedactionPlaceholder(value) {
+  const unquoted = value.length >= 2 && ((value.startsWith('"') && value.endsWith('"'))
+    || (value.startsWith("'") && value.endsWith("'"))) ? value.slice(1, -1) : value;
+  return new RegExp(`^${REDACTION_VALUE}$`).test(unquoted);
+}
+
+function redactAssignment(prefix, value) {
+  if (isRedactionPlaceholder(value)) return `${prefix}${value}`;
+  const quote = value[0] === '"' || value[0] === "'" ? value[0] : '';
+  return `${prefix}${quote}${REDACTION_PLACEHOLDER}${quote}`;
+}
+
+function assignmentMatcher(keyPattern) {
+  return [
+    new RegExp(`(${keyPattern}\\s*[:=]\\s*)(${ASSIGNMENT_VALUE})`, 'gi'),
+    (_match, prefix, value) => redactAssignment(prefix, value),
+  ];
+}
+
+const AUTHORIZATION_MATCHER = [
+  new RegExp(
+    '(["\\\']?authorization["\\\']?\\s*[:=]\\s*(?:(?:bearer|basic)\\s+)?' + ')(' + ASSIGNMENT_VALUE + ')',
+    'gi',
+  ),
+  (_match, prefix, value) => redactAssignment(prefix, value),
+];
+const AUTHORIZATION_FIELD_MATCHER = [
+  new RegExp(
+    '(["\\\']?authorization["\\\']?\\s*[:=]\\s*)(?!(?:\\s*)(?:bearer|basic)\\s+)('
+      + '"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|[^\\r\\n]+)',
+    'gi',
+  ),
+  (_match, prefix, value) => {
+    const leading = value.match(/^\s*/u)?.[0] ?? '';
+    const withoutLeading = value.slice(leading.length);
+    const trailing = withoutLeading.match(/\s*$/u)?.[0] ?? '';
+    const body = trailing ? withoutLeading.slice(0, -trailing.length) : withoutLeading;
+    return `${prefix}${leading}${redactAssignment('', body)}${trailing}`;
+  },
+];
+const BUILT_IN_ASSIGNMENT_MATCHER = assignmentMatcher(
+  String.raw`["']?(?:api[_-]?key|access[_-]?token|password|secret|private[_-]?key)["']?`,
+);
+
 function compareCanonical(left, right) {
   const a = JSON.stringify(left);
   const b = JSON.stringify(right);
@@ -79,11 +124,10 @@ function customMatchers(rules) {
   const tokens = [];
   for (const rule of rules) {
     if (rule.type === 'assignment-key') {
-      const key = escapeRegExp(rule.key);
-      assignments.push([
-        new RegExp(`(?<![A-Za-z0-9_.-])(["']?${key}["']?\\s*[:=]\\s*["']?)(?!\\[REDACTED\\](?=$|[\\s,"'}]))[^\\s,"'}]+`, 'gi'),
-        (_match, prefix) => `${prefix}[REDACTED]`,
-      ]);
+    const key = escapeRegExp(rule.key);
+      assignments.push(assignmentMatcher(
+        String.raw`(?<![A-Za-z0-9_.-])["']?${key}["']?`,
+      ));
     } else {
       const maximum = rule.maxLength === null ? '' : rule.maxLength;
       tokens.push([
@@ -99,8 +143,9 @@ function applyMatchers(text, matchers) {
   let count = 0;
   for (const [pattern, replacement] of matchers) {
     text = text.replace(pattern, (...args) => {
-      count += 1;
-      return typeof replacement === 'function' ? replacement(...args) : replacement;
+      const next = typeof replacement === 'function' ? replacement(...args) : replacement;
+      if (next !== args[0]) count += 1;
+      return next;
     });
   }
   return { text, count };
@@ -110,9 +155,12 @@ export function createRedactionProfile(customRules = []) {
   const rules = normalizeRules(customRules);
   const custom = customMatchers(rules);
   const matchers = [
-    ...BUILT_IN_MATCHERS.slice(0, 3),
+    BUILT_IN_MATCHERS[0],
+    AUTHORIZATION_FIELD_MATCHER,
+    AUTHORIZATION_MATCHER,
+    BUILT_IN_ASSIGNMENT_MATCHER,
     ...custom.assignments,
-    ...BUILT_IN_MATCHERS.slice(3),
+    ...BUILT_IN_MATCHERS.slice(1),
     ...custom.tokens,
   ];
   const digest = `sha256:${createHash('sha256')

package/src/semantic-compactor.mjs

@@ -5,6 +5,8 @@ import { redact, hasSecret } from './secret-redaction.mjs';
 
 export const SEMANTIC_SUMMARY_SCHEMA = 'sando-semantic-summary/v1';
 
+// Ordered extraction guarantees grounding in source text, not preservation of every omitted fact.
+
 const DEFAULT_POLICY = Object.freeze({
   minInputTokens: 8000,
   maxSummaryRatio: 0.2,
@@ -48,7 +50,7 @@ export function buildSemanticPrompt({ provider, model, toolName, text, requiredF
   const required = facts(requiredFacts);
   return [
     `Schema: ${SEMANTIC_SUMMARY_SCHEMA}`,
-    'Summarize the historical tool result for a coding agent.',
+    'Return a concise extractive summary using only complete source lines in their original order; do not paraphrase or invent clauses.',
     'Keep exact paths, identifiers, errors, numbers, negations, and every required fact.',
     'Preserved facts must be copied verbatim from the tool result or required-facts list; do not invent or estimate counts.',
     'Return JSON only with schema, summary, and preservedFacts fields.',
@@ -82,6 +84,15 @@ export function validateSemanticSummary({
   if ((redactionProfile ? redactionProfile.hasSecret(summary) : hasSecret(summary))) {
     return { valid: false, reason: 'secret-detected', inputTokens, outputTokens };
   }
+  const redactedOriginal = redactionProfile ? redactionProfile.redact(originalText).text : redact(originalText).text;
+  const sourceLines = redactedOriginal.split(/\r?\n/);
+  let sourceIndex = 0;
+  for (const line of summary.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const matchIndex = sourceLines.indexOf(line, sourceIndex);
+    if (matchIndex < 0) return { valid: false, reason: 'summary-not-extractive', inputTokens, outputTokens };
+    sourceIndex = matchIndex + 1;
+  }
   return { valid: true, inputTokens, outputTokens };
 }