atris 3.37.1 → 3.40.0

package/lib/wish-delegate.js

@@ -726,7 +726,7 @@ function reviewWish(positionals, root = process.cwd(), options = {}) {
     review_score: score.value === null ? reviewWordScore(reviewText) : score.value,
     reviewed_by: actorName(),
   });
-  console.log(`Review saved for ${quoteText(target.wish.text || target.wish.id)}. It will shape the next run.`);
+  console.log(`Review saved for ${quoteText(target.wish.text || target.wish.id)}. It shapes future runs once distilled into lessons.`);
   return 0;
 }
 
@@ -919,9 +919,13 @@ function startWishDelegation(wish, audit, root, options = {}) {
   const reused = missionPayload && missionPayload.action === 'mission_reused';
   // A delegated wish must have a live worker, not just a filed mission. Start
   // the detached driver for any runner that can work headlessly; runners that
-  // need a live session keep an honest not-started marker instead.
+  // need a live session keep an honest not-started marker instead. A one-lap
+  // intake is the exception: the calling lap dispatches in-process through the
+  // sealed review sandbox, so a detached driver would race it with a second,
+  // ungated dispatch of the same ask.
   let driver = null;
-  if (mission && !missionRunnerNeedsLiveSession(mission.runner) && process.env.ATRIS_WISH_NO_DRIVER !== '1') {
+  const lapOwnsDispatch = options.oneLap === true;
+  if (mission && !lapOwnsDispatch && !missionRunnerNeedsLiveSession(mission.runner) && process.env.ATRIS_WISH_NO_DRIVER !== '1') {
     driver = spawnMissionDriver(mission, root);
   }
   const workerStarted = Boolean(driver && driver.ok && (driver.pid || driver.already_running));
@@ -940,9 +944,11 @@ function startWishDelegation(wish, audit, root, options = {}) {
     worker_started: workerStarted,
     ...(driver && driver.pid ? { driver_pid: driver.pid } : {}),
     ...(mission && !workerStarted ? {
-      worker_note: missionRunnerNeedsLiveSession(mission.runner)
-        ? `waiting for a live ${mission.runner || 'session'} to pick this up`
-        : `worker did not start; run: atris mission run ${mission.id}`,
+      worker_note: lapOwnsDispatch
+        ? 'the one-lap dispatches this in-process'
+        : missionRunnerNeedsLiveSession(mission.runner)
+          ? `waiting for a live ${mission.runner || 'session'} to pick this up`
+          : `worker did not start; run: atris mission run ${mission.id}`,
     } : {}),
     engine: reused ? (mission?.runner || engine) : engine,
     validator: audit.validator.id,
@@ -1422,7 +1428,12 @@ function dispatchWishHeadlessly(wish, root, reason) {
       questions: audit.questions,
     };
   }
-  const { record } = appendDelegatedWishRecord(wish, audit, root);
+  // Preserve one-lap ownership through sweep/headless grant: without this,
+  // a later atris wish sweep would spawn the detached mission driver and race
+  // the lap's sealed in-process dispatch (CLI-1170).
+  const { record } = appendDelegatedWishRecord(wish, audit, root, {
+    oneLap: wish.one_lap === true,
+  });
   return {
     id: wish.id,
     status: 'delegated',
@@ -1531,6 +1542,9 @@ function runCapturedWish(text, root = process.cwd(), options = {}) {
     status: 'captured',
   };
   if (options.parentId) wish.parent_id = String(options.parentId);
+  // One-lap provenance lives on the record so a later `wish answer` also
+  // skips the detached driver: the lap owns dispatch in-process (80de4ae1).
+  if (options.singleTask === true) wish.one_lap = true;
   if (engineOverride) wish.requested_engine = engineOverride;
   if (options.metric && options.metric.ok) wish.metric = options.metric.expression;
   captureWishToJournal(text, root);
@@ -1539,7 +1553,10 @@ function runCapturedWish(text, root = process.cwd(), options = {}) {
   const taskText = wishBodyText(text);
   const verifyPlan = options.verifyPlan || deriveVerifyPlan(text);
   const decompositionVerifyPlan = options.verifyPlan || (verifyPlan.status === 'explicit' ? verifyPlan : null);
-  const audit = auditWish(taskText, root, { engineOverride });
+  // A one-lap intake owns dispatch and validation policy in-process, so its
+  // route must stay deterministic across machines: never interview about the
+  // reviewer just because no validator binary is installed here.
+  const audit = auditWish(taskText, root, { engineOverride, assumeValidator: options.singleTask === true });
   if (builderMode) return builderWish(wish, audit, root, asJson);
   const parts = options.singleTask ? null : analyzeWishParts(text, root);
   if (parts && noMission) return captureOnlyWish(wish, null, root, asJson);
@@ -1552,6 +1569,7 @@ function runCapturedWish(text, root = process.cwd(), options = {}) {
   return delegateWish(wish, audit, root, asJson, {
     taskText,
     recordText: wish.text,
+    oneLap: options.singleTask === true,
     ...(options.metric ? { metric: options.metric } : {}),
     verifyPlan,
     userVerifyProvided: options.userVerifyProvided === true || verifyPlan.status === 'explicit',
@@ -1622,7 +1640,7 @@ function applyAnswer(wish, answer, root, options = {}) {
   const audit = bestGuessAfterRepeatedQuestion(answeredWish, audited, root);
   if (!audit.ok) return askForInput(answeredWish, audit, root, asJson);
   if (noMission) return captureOnlyWish(answeredWish, audit, root, asJson);
-  return delegateWish(answeredWish, audit, root, asJson, {});
+  return delegateWish(answeredWish, audit, root, asJson, { oneLap: wish.one_lap === true });
 }
 
 function sameWaitingPart(left, right) {
@@ -1811,25 +1829,13 @@ function grantWish(positionals, root = process.cwd(), options = {}) {
 module.exports = {
   REVIEW_WORD_SCORES,
   answerWish,
-  appendDelegatedWishRecord,
-  appendNeedsInputRecord,
-  askForInput,
-  captureOnlyWish,
   captureWishToJournal,
-  delegateWish,
-  dispatchWishHeadlessly,
-  fulfillLandedWishes,
   grantWish,
-  metricVerifierCommand,
-  listedWishes,
-  openWishes,
   parseMetricExpression,
   printBoard,
   printList,
   printReviewNudges,
   printRewards,
-  reviewNudgeWishes,
-  reviewWordScore,
   reviewWish,
   runAgainWish,
   runCapturedWish,

package/lib/wish-stats.js

@@ -173,11 +173,6 @@ function printWishStats(root = process.cwd(), options = {}) {
 }
 
 module.exports = {
-  buildWishStats,
-  haikuRates,
-  missionReceiptFiles,
   printWishStats,
   verifierPassed,
-  wishStatsLogPath,
-  writeWishStats,
 };

package/lib/wish-store.js

@@ -338,7 +338,6 @@ module.exports = {
   improveWishes,
   lessonsFile,
   pruneWishLessons,
-  readWishLessonLines,
   wishLessonsBrief,
   wishLessonsSummary,
   latestWishEventMap,

package/lib/workspace-safety.js

@@ -80,8 +80,6 @@ function assertSafeWorkspaceRoot(dir, { slug, op } = {}) {
 }
 
 module.exports = {
-  dangerousWorkspaceReason,
-  safeFallbackDir,
   resolveSafeOutputDir,
   assertSafeWorkspaceRoot,
 };

package/lib/zip.js

@@ -11,6 +11,13 @@ const UTF8_FLAG = 0x0800;
 const DEFLATE = 8;
 const STORE = 0;
 
+const ZIP_LIMITS = Object.freeze({
+  maxZipBytes: 5 * 1024 * 1024,
+  maxUnpackedBytes: 20 * 1024 * 1024,
+  maxEntryBytes: 20 * 1024 * 1024,
+  maxEntries: 500,
+});
+
 let crcTable = null;
 
 function getCrcTable() {
@@ -155,24 +162,56 @@ function assertReadable(buffer, offset, length, label) {
   }
 }
 
-function readZipBuffer(input) {
+function readLimits(options = {}) {
+  return {
+    maxZipBytes: options.maxZipBytes ?? ZIP_LIMITS.maxZipBytes,
+    maxUnpackedBytes: options.maxUnpackedBytes ?? ZIP_LIMITS.maxUnpackedBytes,
+    maxEntryBytes: options.maxEntryBytes ?? ZIP_LIMITS.maxEntryBytes,
+    maxEntries: options.maxEntries ?? ZIP_LIMITS.maxEntries,
+  };
+}
+
+function assertWithinLimit(value, limit, message) {
+  if (!Number.isFinite(limit) || limit < 0) {
+    throw new Error('invalid zip read limit');
+  }
+  if (value > limit) throw new Error(message);
+}
+
+function readZipBuffer(input, options = {}) {
   const buffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+  const limits = readLimits(options);
+  assertWithinLimit(
+    buffer.length,
+    limits.maxZipBytes,
+    `refusing zip: archive size ${buffer.length} bytes exceeds ${limits.maxZipBytes} byte limit`,
+  );
   const endOffset = findEndOfCentralDirectory(buffer);
   const entryCount = buffer.readUInt16LE(endOffset + 10);
   const centralSize = buffer.readUInt32LE(endOffset + 12);
   const centralOffset = buffer.readUInt32LE(endOffset + 16);
+  assertWithinLimit(
+    entryCount,
+    limits.maxEntries,
+    `refusing zip: ${entryCount} entries exceeds ${limits.maxEntries} entry limit`,
+  );
   assertReadable(buffer, centralOffset, centralSize, 'central directory');
 
-  const entries = [];
+  const metadata = [];
+  const centralEnd = centralOffset + centralSize;
+  let declaredUnpackedBytes = 0;
   let cursor = centralOffset;
   for (let i = 0; i < entryCount; i += 1) {
-    assertReadable(buffer, cursor, 46, 'central directory entry');
+    if (cursor + 46 > centralEnd) {
+      throw new Error('invalid zip: truncated central directory entry');
+    }
     if (buffer.readUInt32LE(cursor) !== CENTRAL_DIRECTORY_HEADER) {
       throw new Error('invalid zip: malformed central directory');
     }
 
     const flags = buffer.readUInt16LE(cursor + 8);
     const method = buffer.readUInt16LE(cursor + 10);
+    const expectedCrc = buffer.readUInt32LE(cursor + 16);
     const compressedSize = buffer.readUInt32LE(cursor + 20);
     const uncompressedSize = buffer.readUInt32LE(cursor + 24);
     const nameLength = buffer.readUInt16LE(cursor + 28);
@@ -180,7 +219,9 @@ function readZipBuffer(input) {
     const commentLength = buffer.readUInt16LE(cursor + 32);
     const localOffset = buffer.readUInt32LE(cursor + 42);
     const nameStart = cursor + 46;
-    assertReadable(buffer, nameStart, nameLength + extraLength + commentLength, 'central directory name');
+    if (nameStart + nameLength + extraLength + commentLength > centralEnd) {
+      throw new Error('invalid zip: truncated central directory name');
+    }
     const name = buffer.slice(nameStart, nameStart + nameLength).toString('utf8');
     cursor = nameStart + nameLength + extraLength + commentLength;
 
@@ -189,6 +230,39 @@ function readZipBuffer(input) {
       throw new Error(`invalid zip: unsupported compression method ${method} for ${name}`);
     }
 
+    assertWithinLimit(
+      uncompressedSize,
+      limits.maxEntryBytes,
+      `refusing zip: entry ${name} declares ${uncompressedSize} unpacked bytes, exceeding ${limits.maxEntryBytes} byte entry limit`,
+    );
+    declaredUnpackedBytes += uncompressedSize;
+    assertWithinLimit(
+      declaredUnpackedBytes,
+      limits.maxUnpackedBytes,
+      `refusing zip: declared unpacked size ${declaredUnpackedBytes} bytes exceeds ${limits.maxUnpackedBytes} byte limit`,
+    );
+
+    metadata.push({
+      name,
+      flags,
+      method,
+      expectedCrc,
+      compressedSize,
+      uncompressedSize,
+      localOffset,
+    });
+  }
+
+  const entries = [];
+  for (const entry of metadata) {
+    const {
+      name,
+      method,
+      expectedCrc,
+      compressedSize,
+      uncompressedSize,
+      localOffset,
+    } = entry;
     assertReadable(buffer, localOffset, 30, 'local file header');
     if (buffer.readUInt32LE(localOffset) !== LOCAL_FILE_HEADER) {
       throw new Error(`invalid zip: missing local header for ${name}`);
@@ -198,18 +272,31 @@ function readZipBuffer(input) {
     const dataStart = localOffset + 30 + localNameLength + localExtraLength;
     assertReadable(buffer, dataStart, compressedSize, `file data for ${name}`);
     const compressed = buffer.slice(dataStart, dataStart + compressedSize);
-    const data = method === STORE ? Buffer.from(compressed) : zlib.inflateRawSync(compressed);
+    let data;
+    try {
+      data = method === STORE
+        ? Buffer.from(compressed)
+        : zlib.inflateRawSync(compressed, { maxOutputLength: Math.max(1, uncompressedSize) });
+    } catch (error) {
+      if (error && error.code === 'ERR_BUFFER_TOO_LARGE') {
+        throw new Error(`invalid zip: inflated data exceeds declared size for ${name}`);
+      }
+      throw new Error(`invalid zip: could not inflate ${name}: ${error.message}`);
+    }
     if (data.length !== uncompressedSize) {
       throw new Error(`invalid zip: size mismatch for ${name}`);
     }
+    if (crc32(data) !== expectedCrc) {
+      throw new Error(`invalid zip: checksum mismatch for ${name}`);
+    }
     entries.push({ name, data });
   }
 
   return entries;
 }
 
-function readZipFile(filePath) {
-  return readZipBuffer(fs.readFileSync(filePath));
+function readZipFile(filePath, options = {}) {
+  return readZipBuffer(fs.readFileSync(filePath), options);
 }
 
 module.exports = {
@@ -217,5 +304,5 @@ module.exports = {
   writeZipFile,
   readZipBuffer,
   readZipFile,
-  crc32,
+  ZIP_LIMITS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.37.1",
+  "version": "3.40.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {
@@ -57,6 +57,7 @@
     "test": "node --test",
     "test:fast": "xargs node --test < test/fast-tests.txt",
     "lint:decks": "node scripts/lint-all-decks.js",
+    "audit:markdown-whitespace": "node scripts/audit-markdown-whitespace.js",
     "publish:release": "node scripts/publish-atris-release.js",
     "prepare": "cp scripts/pre-commit .git/hooks/pre-commit 2>/dev/null && cp scripts/commit-msg .git/hooks/commit-msg 2>/dev/null && cp scripts/prepare-commit-msg .git/hooks/prepare-commit-msg 2>/dev/null && chmod +x .git/hooks/pre-commit .git/hooks/commit-msg .git/hooks/prepare-commit-msg || true"
   },

package/templates/business-starter/persona.md

@@ -18,6 +18,15 @@ Keep this file aligned with `atris/persona.md`.
 - Concrete examples over abstractions
 - Cite the source when answering domain questions
 
+## The Way Of Talking (every message a human reads)
+
+- Plain words. Say what happened and what it means for the reader — cause and effect, not machinery.
+- No task codes, commit hashes, or internal system names in the message body. If the reader needs a code to act, put ONE copyable command at the end.
+- No insider terms without defining them in the same breath.
+- One idea per line. Outcome first. Detail lives in files, not the message.
+- Lists: spell the numbers as words (One. Two. Three.), each item its own paragraph with a blank line between. Never markdown numbered lists — they render cramped.
+- The test: a sharp, tired non-engineer follows it on first read. If not, rewrite.
+
 ## Anti-patterns
 
 - No em dashes in outbound copy