atris 3.38.0 → 3.40.0

package/lib/voice-gate.js

@@ -215,10 +215,76 @@ function isRetiredFillerReason(text) {
   return RETIRED_FILLER_REASON.test(String(text || '').replace(/\s+/g, ' ').trim());
 }
 
+// One table turns every landing/refusal reason code into a plain sentence a
+// fried reader can act on: what happened, and what unblocks it. JSON output
+// keeps the raw codes; only human text goes through here. Fragments carry no
+// trailing period because callers stitch them into their own sentences.
+const LANDING_REASON_SENTENCES = {
+  accept_all_but_protected: 'the accept-everything policy covers it, so it lands unless a protected lane applies',
+  already_auto_accepted: 'it already landed on its own earlier, nothing left to do',
+  autoland_policy_missing_owner: 'the self-landing policy has no owner recorded, turn it on again to set one',
+  autoland_policy_off: 'self-landing is off, so everything waits for you',
+  certified_independent_review: 'an independent reviewer certified it, so it can land',
+  certified_strict_verify: 'it is certified and its recorded check passed, so it can land',
+  dead_exports: 'the change leaves behind code nothing calls, delete what the hygiene check names and re-certify',
+  declared_protected_lane: 'it touches a protected lane, so it waits for your decision',
+  forced_completion_needs_human: 'it was pushed to done without proof, so only a human can accept it',
+  insufficient_review_passes: 'it has not been reviewed enough times yet, one more pass unblocks it',
+  judge_equals_worker: 'built and judged by the same actor, hand the review to someone else',
+  mission_xp_requires_end_to_end_receipt: 'the proof does not show the whole flow working start to finish, attach that receipt or move it back to do',
+  needs_independent_reviewer: 'built and judged by the same actor, a review from someone else unblocks it',
+  needs_second_actor_review: 'the same actor built and reviewed it, someone else has to look before it lands',
+  needs_second_reviewer_or_third_pass: 'it needs one more independent check first',
+  no_verify_command: 'no check command was given, add one so the work can prove itself',
+  not_agent_certified: 'no reviewer has certified it yet, a second review unblocks it',
+  not_in_review: 'it is not up for review yet, finish the work and move it to review first',
+  probation_needs_review: 'the builder is still earning trust, so a human look is required before it lands',
+  proof_not_executed: 'the proof was written but never actually run, execute the check and record what it showed',
+  proof_required: 'no proof was given, say what was run and what it showed',
+  proof_unmerged_or_draft_pr_boundary: 'its proof points at an unmerged draft, merge it or prove the work another way',
+  receipt_verifier_failed: 'a saved receipt failed its re-check, fix what it names and re-certify',
+  strict_verify_missing: 'no recorded check command to re-run, add one and re-certify',
+  untagged_protected_lane_text: 'the description reads like protected-lane work without the tag, tag it or decide it yourself',
+  verification_pending: 'the recorded check has not been re-run yet, the next hourly pass runs it',
+  verifier_is_builder: 'the re-check actor built this row, another actor must re-check',
+  verify_command_not_allowed: 'its recorded check is not on the list this machine may run alone, run it yourself to unblock',
+  verify_failed: 'its check command failed on re-run, fix the failure and re-certify',
+  verify_passed: 'its check command passed on re-run',
+  verify_unrunnable: 'its check command could not even start, fix the command and re-certify',
+  verify_workdir_missing: 'the folder its check was recorded in is gone, re-run the check from a real folder',
+  verify_worktree_missing: 'the folder its check needs is gone, rebuild it or run the check by hand',
+  weak_proof: 'the proof is too thin to trust, cite a command, receipt, or approval',
+};
+
+const DENIED_TAG_SENTENCES = {
+  billing: 'it touches money, so it is your decision',
+  deploy: 'it is a deploy, so it is your decision',
+  security: 'it touches security, so it is your decision',
+  customer: 'it is customer-facing, so it is your decision',
+  external: 'it is outward-facing, so it is your decision',
+  feedback: 'it answers customer feedback, so it is your decision',
+};
+
+function plainLandingReason(reason) {
+  const code = String(reason || '').trim();
+  if (!code) return 'no reason was recorded, re-run the review to get one';
+  if (LANDING_REASON_SENTENCES[code]) return LANDING_REASON_SENTENCES[code];
+  const denied = code.match(/^denied_tag_(.+)$/);
+  if (denied) {
+    return DENIED_TAG_SENTENCES[denied[1]]
+      || `it is tagged ${denied[1].replace(/_/g, ' ')}, a protected lane, so it is your decision`;
+  }
+  const approval = code.match(/^approval_(.+)$/);
+  if (approval) return `a human already marked it ${approval[1].replace(/_/g, ' ')}, so it will not land on its own`;
+  // Unknown codes still never leak snake_case to a human.
+  return code.replace(/_/g, ' ');
+}
+
 module.exports = {
   gateForHuman,
   isRetiredFillerReason,
   landingWhyClause,
   numberWord,
+  plainLandingReason,
   scanText,
 };

package/lib/wish-audit.js

@@ -167,7 +167,7 @@ const BUDGET_LABELS = {
 const WISH_SWEEP_LIMIT = 3;
 const WISH_MISSION_RUNNER = 'claude';
 const TEST_VERIFY_COMMAND = 'node --test';
-const JOURNAL_RESULT_TEXT = 'a written result will be waiting in your journal';
+const JOURNAL_RESULT_TEXT = 'the wish is recorded and the result comes back for review';
 const WAITING_INPUT_STATUSES = new Set(['needs_input', 'waiting_input']);
 const PATH_SLOT_QUESTION = 'Where should I find the file or folder you named?';
 const AUDIENCE_WORDS = /\b(?:for|user|users|customer|customers|operator|operators|agent|agents|developer|developers|admin|admins|member|members|team|teams|visitor|visitors|client|clients|student|students|founder|founders|newcomer|newcomers)\b/i;

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;
 }
 

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,4 +304,5 @@ module.exports = {
   writeZipFile,
   readZipBuffer,
   readZipFile,
+  ZIP_LIMITS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.38.0",
+  "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