@tekmidian/pai 0.63.0 → 0.65.0

package/dist/{helpers-Dj-B314s.mjs → helpers-BRCJg0G3.mjs}

@@ -3,212 +3,6 @@ import { homedir } from "node:os";
 import { basename, join, normalize } from "node:path";
 import { createHash } from "node:crypto";
 
-//#region src/utils/hash.ts
-/**
-* Shared hashing utilities. Centralises all SHA-256 usage so every module
-* obtains digests through the same function rather than inlining createHash.
-*/
-/**
-* Compute a SHA-256 hex digest of the given string.
-* Aliased as sha256File for compatibility with existing call-sites that use
-* that name to hash file contents.
-*/
-function sha256(content) {
-	return createHash("sha256").update(content).digest("hex");
-}
-/** Alias kept for backwards compatibility with memory/indexer call-sites. */
-const sha256File = sha256;
-
-//#endregion
-//#region src/memory/chunker.ts
-/**
-* Markdown text chunker for the PAI memory engine.
-*
-* Splits markdown files into overlapping text segments suitable for BM25
-* full-text indexing.  Respects heading boundaries where possible, falling
-* back to paragraph and sentence splitting when sections are large.
-*/
-const DEFAULT_MAX_TOKENS = 400;
-const DEFAULT_OVERLAP = 80;
-/**
-* Approximate token count using a words * 1.3 heuristic.
-* Matches the OpenClaw estimate approach.
-*/
-function estimateTokens(text) {
-	const wordCount = text.split(/\s+/).filter(Boolean).length;
-	return Math.ceil(wordCount * 1.3);
-}
-/**
-* Split content into sections delimited by ## or ### headings.
-* Each section starts at its heading line (or at line 1 for a preamble).
-*/
-function splitBySections(lines) {
-	const sections = [];
-	let current = [];
-	for (const line of lines) {
-		if (/^#{1,3}\s/.test(line.text) && current.length > 0) {
-			const text = current.map((l) => l.text).join("\n");
-			sections.push({
-				lines: current,
-				tokens: estimateTokens(text)
-			});
-			current = [];
-		}
-		current.push(line);
-	}
-	if (current.length > 0) {
-		const text = current.map((l) => l.text).join("\n");
-		sections.push({
-			lines: current,
-			tokens: estimateTokens(text)
-		});
-	}
-	return sections;
-}
-/**
-* Split a LineBlock by double-newline paragraph boundaries.
-*/
-function splitByParagraphs(block) {
-	const paragraphs = [];
-	let current = [];
-	for (const line of block.lines) if (line.text.trim() === "" && current.length > 0) {
-		const text = current.map((l) => l.text).join("\n");
-		paragraphs.push({
-			lines: [...current],
-			tokens: estimateTokens(text)
-		});
-		current = [];
-	} else current.push(line);
-	if (current.length > 0) {
-		const text = current.map((l) => l.text).join("\n");
-		paragraphs.push({
-			lines: current,
-			tokens: estimateTokens(text)
-		});
-	}
-	return paragraphs.length > 0 ? paragraphs : [block];
-}
-/**
-* Split a LineBlock by sentence boundaries (. ! ?) when even paragraphs are
-* too large.  Works character-by-character within joined lines.
-*/
-function splitBySentences(block, maxTokens) {
-	const sentences = block.lines.map((l) => l.text).join(" ").split(/(?<=[.!?])\s+(?=[A-Z"'])/g);
-	const result = [];
-	let accText = "";
-	const startLine = block.lines[0]?.lineNo ?? 1;
-	const endLine = block.lines[block.lines.length - 1]?.lineNo ?? startLine;
-	const totalLines = endLine - startLine + 1;
-	const linesPerSentence = Math.max(1, Math.floor(totalLines / Math.max(1, sentences.length)));
-	let sentenceIdx = 0;
-	let approxLine = startLine;
-	const flush = () => {
-		if (!accText.trim()) return;
-		const endApprox = Math.min(approxLine + linesPerSentence - 1, endLine);
-		result.push({
-			lines: [{
-				text: accText.trim(),
-				lineNo: approxLine
-			}],
-			tokens: estimateTokens(accText)
-		});
-		approxLine = endApprox + 1;
-		accText = "";
-	};
-	for (const sentence of sentences) {
-		sentenceIdx++;
-		const candidateText = accText ? accText + " " + sentence : sentence;
-		if (estimateTokens(candidateText) > maxTokens && accText) {
-			flush();
-			accText = sentence;
-		} else accText = candidateText;
-	}
-	flush();
-	return result.length > 0 ? result : [block];
-}
-/**
-* Extract the last `overlapTokens` worth of text from a list of previously
-* emitted chunks to prepend to the next chunk.
-*/
-function buildOverlapPrefix(chunks, overlapTokens) {
-	if (overlapTokens <= 0 || chunks.length === 0) return [];
-	const lastChunk = chunks[chunks.length - 1];
-	if (!lastChunk) return [];
-	const lines = lastChunk.text.split("\n");
-	const kept = [];
-	let acc = 0;
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const lineTokens = estimateTokens(lines[i] ?? "");
-		acc += lineTokens;
-		kept.unshift(lines[i] ?? "");
-		if (acc >= overlapTokens) break;
-	}
-	const startLine = lastChunk.endLine - kept.length + 1;
-	return kept.map((text, idx) => ({
-		text,
-		lineNo: Math.max(lastChunk.startLine, startLine + idx)
-	}));
-}
-/**
-* Chunk a markdown file into overlapping segments for BM25 indexing.
-*
-* Strategy:
-*  1. Split by headings (##, ###) as natural boundaries.
-*  2. If a section exceeds maxTokens, split by paragraphs.
-*  3. If a paragraph still exceeds maxTokens, split by sentences.
-*  4. Apply overlap: each chunk includes the last `overlap` tokens from the
-*     previous chunk.
-*/
-/**
-* Strip `<private>...</private>` blocks from content before indexing.
-* Content within these tags is excluded from memory — never stored or searched.
-*/
-function stripPrivateTags(content) {
-	return content.replace(/<private>[\s\S]*?<\/private>/gi, "");
-}
-function chunkMarkdown(content, opts) {
-	const maxTokens = opts?.maxTokens ?? DEFAULT_MAX_TOKENS;
-	const overlapTokens = opts?.overlap ?? DEFAULT_OVERLAP;
-	content = stripPrivateTags(content);
-	if (!content.trim()) return [];
-	const sections = splitBySections(content.split("\n").map((text, idx) => ({
-		text,
-		lineNo: idx + 1
-	})));
-	const finalBlocks = [];
-	for (const section of sections) {
-		if (section.tokens <= maxTokens) {
-			finalBlocks.push(section);
-			continue;
-		}
-		const paras = splitByParagraphs(section);
-		for (const para of paras) {
-			if (para.tokens <= maxTokens) {
-				finalBlocks.push(para);
-				continue;
-			}
-			const sentences = splitBySentences(para, maxTokens);
-			finalBlocks.push(...sentences);
-		}
-	}
-	const chunks = [];
-	for (const block of finalBlocks) {
-		if (block.lines.length === 0) continue;
-		const text = [...buildOverlapPrefix(chunks, overlapTokens), ...block.lines].map((l) => l.text).join("\n").trim();
-		if (!text) continue;
-		const startLine = block.lines[0]?.lineNo ?? 1;
-		const endLine = block.lines[block.lines.length - 1]?.lineNo ?? startLine;
-		chunks.push({
-			text,
-			startLine,
-			endLine,
-			hash: sha256(text)
-		});
-	}
-	return chunks;
-}
-
-//#endregion
 //#region src/memory/indexer/helpers.ts
 /**
 * Shared helpers for the PAI memory indexers.
@@ -425,5 +219,5 @@ function parseSessionTitleChunk(fileName) {
 const INDEX_YIELD_EVERY = 10;
 
 //#endregion
-export { parseSessionTitleChunk as a, yieldToEventLoop as c, sha256 as d, sha256File as f, isPathTooBroadForContentScan as i, chunkMarkdown as l, chunkId as n, walkContentFiles as o, detectTier as r, walkMdFiles as s, INDEX_YIELD_EVERY as t, estimateTokens as u };
-//# sourceMappingURL=helpers-Dj-B314s.mjs.map
+export { parseSessionTitleChunk as a, yieldToEventLoop as c, isPathTooBroadForContentScan as i, chunkId as n, walkContentFiles as o, detectTier as r, walkMdFiles as s, INDEX_YIELD_EVERY as t };
+//# sourceMappingURL=helpers-BRCJg0G3.mjs.map

package/dist/helpers-BRCJg0G3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers-BRCJg0G3.mjs","names":[],"sources":["../src/memory/indexer/helpers.ts"],"sourcesContent":["/**\n * Shared helpers for the PAI memory indexers.\n *\n * Contains utilities used by both the sync (SQLite) and async (StorageBackend)\n * indexer paths: hashing, chunk ID generation, directory walking, and path guards.\n */\n\nimport { readdirSync, existsSync } from \"node:fs\";\nimport { createHash } from \"node:crypto\";\nimport { sha256File } from \"../../utils/hash.js\";\nimport { join, normalize } from \"node:path\";\nimport { homedir } from \"node:os\";\nimport { basename } from \"node:path\";\n\n// ---------------------------------------------------------------------------\n// Tier detection\n// ---------------------------------------------------------------------------\n\n/**\n * Classify a relative file path into one of the four memory tiers.\n *\n * Rules (in priority order):\n *  - MEMORY.md anywhere in memory/  → 'evergreen'\n *  - YYYY-MM-DD.md in memory/       → 'daily'\n *  - anything else in memory/       → 'topic'\n *  - anything in Notes/             → 'session'\n */\nexport function detectTier(\n  relativePath: string,\n): \"evergreen\" | \"daily\" | \"topic\" | \"session\" {\n  // Normalise to forward slashes and strip leading ./\n  const p = relativePath.replace(/\\\\/g, \"/\").replace(/^\\.\\//, \"\");\n\n  // Notes directory → session tier\n  if (p.startsWith(\"Notes/\") || p === \"Notes\") {\n    return \"session\";\n  }\n\n  const fileName = basename(p);\n\n  // MEMORY.md (case-sensitive match) → evergreen\n  if (fileName === \"MEMORY.md\") {\n    return \"evergreen\";\n  }\n\n  // YYYY-MM-DD.md → daily\n  if (/^\\d{4}-\\d{2}-\\d{2}\\.md$/.test(fileName)) {\n    return \"daily\";\n  }\n\n  // Default for memory/ files\n  return \"topic\";\n}\n\n// ---------------------------------------------------------------------------\n// Hashing and chunk ID generation\n// ---------------------------------------------------------------------------\n\n// sha256File imported from ../../utils/hash.js\nexport { sha256File } from \"../../utils/hash.js\";\n\n/**\n * Generate a deterministic chunk ID from its coordinates.\n * Format: sha256(\"projectId:path:chunkIndex:startLine:endLine\")\n *\n * The chunkIndex (0-based position within the file) is included so that\n * chunks with approximated line numbers (e.g. from splitBySentences) never\n * produce colliding IDs even when multiple chunks share the same startLine/endLine.\n */\nexport function chunkId(\n  projectId: number,\n  path: string,\n  chunkIndex: number,\n  startLine: number,\n  endLine: number,\n): string {\n  return createHash(\"sha256\")\n    .update(`${projectId}:${path}:${chunkIndex}:${startLine}:${endLine}`)\n    .digest(\"hex\");\n}\n\n// ---------------------------------------------------------------------------\n// Event loop yield\n// ---------------------------------------------------------------------------\n\n/**\n * Yield to the Node.js event loop so that IPC server can process requests\n * during long index runs.\n *\n * Uses setTimeout(10ms) rather than setImmediate — the 10ms pause gives the\n * event loop enough time to accept and process incoming IPC connections\n * (socket data, new connections, etc.). Without this, synchronous ONNX\n * inference blocks IPC for the full duration of each embedding (~50-100ms\n * per chunk).\n */\nexport function yieldToEventLoop(): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, 10));\n}\n\n// ---------------------------------------------------------------------------\n// Directory skip sets\n// ---------------------------------------------------------------------------\n\n/**\n * Directories to ALWAYS skip, at any depth, during any directory walk.\n * These are build artifacts, dependency trees, and VCS internals that\n * should never be indexed regardless of where they appear in the tree.\n */\nexport const ALWAYS_SKIP_DIRS = new Set([\n  // Version control\n  \".git\",\n  // Dependency directories (any language)\n  \"node_modules\",\n  \"vendor\",\n  \"Pods\",              // CocoaPods (iOS/macOS)\n  // Build / compile output\n  \"dist\",\n  \"build\",\n  \"out\",\n  \"DerivedData\",       // Xcode\n  \".next\",             // Next.js\n  // Python virtual environments and caches\n  \".venv\",\n  \"venv\",\n  \"__pycache__\",\n  // General caches\n  \".cache\",\n  \".bun\",\n  // Backup snapshots (Carbon Copy Cloner, Time Machine, etc.)\n  \"snaps\",\n  \".Trashes\",\n  // Worker worktrees — full repo copies checked out per worker run\n  \"worktrees\",\n]);\n\n/**\n * Directories to skip when doing a root-level content scan.\n * These are either already handled by dedicated scans or should never be indexed.\n */\nexport const ROOT_SCAN_SKIP_DIRS = new Set([\n  \"memory\",\n  \"Notes\",\n  \".claude\",\n  \".DS_Store\",\n  // Everything in ALWAYS_SKIP_DIRS is also excluded at root level\n  ...ALWAYS_SKIP_DIRS,\n]);\n\n/**\n * Additional directories to skip at the content-scan level (first level below root).\n * These are common macOS/Linux home-directory or repo noise directories that are\n * never meaningful as project content.\n */\nexport const CONTENT_SCAN_SKIP_DIRS = new Set([\n  // macOS home directory standard folders\n  \"Library\",\n  \"Applications\",\n  \"Music\",\n  \"Movies\",\n  \"Pictures\",\n  \"Desktop\",\n  \"Downloads\",\n  \"Public\",\n  // Common dev noise\n  \"coverage\",\n  // Everything in ALWAYS_SKIP_DIRS is also excluded at this level\n  ...ALWAYS_SKIP_DIRS,\n]);\n\n// ---------------------------------------------------------------------------\n// Directory walkers\n// ---------------------------------------------------------------------------\n\n/**\n * Safety cap: maximum number of .md files collected per project scan.\n * Prevents runaway scans on huge root paths (e.g. home directory).\n * Projects with more files than this are scanned up to the cap only.\n */\nconst MAX_FILES_PER_PROJECT = 5_000;\n\n/**\n * Maximum recursion depth for directory walks.\n * Prevents deep traversal of large directory trees (e.g. development repos).\n * Depth 0 = the given directory itself (no recursion).\n * Value 6 allows: root → subdirs → sub-subdirs → ... up to 6 levels.\n * Sufficient for memory/, Notes/, and typical docs structures.\n */\nconst MAX_WALK_DEPTH = 6;\n\n/**\n * Recursively collect all .md files under a directory.\n * Returns absolute paths. Stops early if the accumulated count hits the cap\n * or if the recursion depth exceeds MAX_WALK_DEPTH.\n *\n * @param dir    Directory to scan.\n * @param acc    Shared accumulator array (mutated in place for early exit).\n * @param cap    Maximum number of files to collect (across all recursive calls).\n * @param depth  Current recursion depth (0 = the initial call).\n */\nexport function walkMdFiles(\n  dir: string,\n  acc?: string[],\n  cap = MAX_FILES_PER_PROJECT,\n  depth = 0,\n): string[] {\n  const results = acc ?? [];\n  if (!existsSync(dir)) return results;\n  if (results.length >= cap) return results;\n  if (depth > MAX_WALK_DEPTH) return results;\n\n  try {\n    for (const entry of readdirSync(dir, { withFileTypes: true })) {\n      if (results.length >= cap) break;\n      if (entry.isSymbolicLink()) continue;\n      // Skip known junk directories at every recursion depth\n      if (ALWAYS_SKIP_DIRS.has(entry.name)) continue;\n      const full = join(dir, entry.name);\n      if (entry.isDirectory()) {\n        walkMdFiles(full, results, cap, depth + 1);\n      } else if (entry.isFile() && entry.name.endsWith(\".md\")) {\n        results.push(full);\n      }\n    }\n  } catch {\n    // Unreadable directory — skip\n  }\n  return results;\n}\n\n/**\n * Recursively collect all .md files under rootPath, excluding directories\n * that are already covered by dedicated scans (memory/, Notes/) and\n * common noise directories (.git, node_modules, etc.).\n *\n * Returns absolute paths for files NOT already handled by the specific scanners.\n * Stops collecting once MAX_FILES_PER_PROJECT is reached.\n */\nexport function walkContentFiles(rootPath: string): string[] {\n  if (!existsSync(rootPath)) return [];\n\n  const results: string[] = [];\n  try {\n    for (const entry of readdirSync(rootPath, { withFileTypes: true })) {\n      if (results.length >= MAX_FILES_PER_PROJECT) break;\n      if (entry.isSymbolicLink()) continue;\n      if (ROOT_SCAN_SKIP_DIRS.has(entry.name)) continue;\n      if (CONTENT_SCAN_SKIP_DIRS.has(entry.name)) continue;\n\n      const full = join(rootPath, entry.name);\n      if (entry.isDirectory()) {\n        walkMdFiles(full, results, MAX_FILES_PER_PROJECT);\n      } else if (entry.isFile() && entry.name.endsWith(\".md\")) {\n        // Skip root-level MEMORY.md — handled by the dedicated evergreen scan\n        if (entry.name !== \"MEMORY.md\") {\n          results.push(full);\n        }\n      }\n    }\n  } catch {\n    // Unreadable directory — skip\n  }\n  return results;\n}\n\n// ---------------------------------------------------------------------------\n// Path safety guard\n// ---------------------------------------------------------------------------\n\n/** Paths that must never be indexed — system/temp dirs that can contain backup snapshots. */\nconst BLOCKED_ROOTS = new Set([\"/tmp\", \"/private/tmp\", \"/var\", \"/private/var\"]);\n\n/**\n * Returns true if rootPath should skip the recursive content scan.\n *\n * Skips content scanning for:\n *  - The home directory itself or any ancestor (too broad — millions of files)\n *  - Git repositories (code repos — index memory/ and Notes/ only, not all .md files)\n *\n * The content scan is still useful for Obsidian vaults, Notes folders, and\n * other doc-centric project trees where ALL markdown files are meaningful.\n *\n * The memory/, Notes/, and claude_notes_dir scans always run regardless.\n */\nexport function isPathTooBroadForContentScan(rootPath: string): boolean {\n  const normalized = normalize(rootPath);\n\n  // Block system/temp directories outright (CCC snapshots live here)\n  if (BLOCKED_ROOTS.has(normalized)) return true;\n  for (const blocked of BLOCKED_ROOTS) {\n    if (normalized.startsWith(blocked + \"/\")) return true;\n  }\n\n  const home = homedir();\n\n  // Skip the home directory itself or any ancestor of home\n  if (home.startsWith(normalized) || normalized === \"/\") {\n    return true;\n  }\n\n  // Skip home directory itself (depth 0)\n  if (normalized.startsWith(home)) {\n    const rel = normalized.slice(home.length).replace(/^\\//, \"\");\n    const depth = rel ? rel.split(\"/\").length : 0;\n    if (depth === 0) return true;\n  }\n\n  // Skip git repositories — content scan is only for doc-centric projects\n  // (Obsidian vaults, knowledge bases). Code repos use memory/ and Notes/ only.\n  if (existsSync(join(normalized, \".git\"))) {\n    return true;\n  }\n\n  return false;\n}\n\n// ---------------------------------------------------------------------------\n// Session title parser\n// ---------------------------------------------------------------------------\n\nconst SESSION_TITLE_RE = /^(\\d{4})\\s*-\\s*(\\d{4}-\\d{2}-\\d{2})\\s*-\\s*(.+)\\.md$/;\n\n/**\n * Parse a session title from a Notes filename.\n * Format: \"NNNN - YYYY-MM-DD - Descriptive Title.md\"\n * Returns a synthetic chunk text like \"Session #0086 2026-02-23: Pai Daemon Background Service\"\n * or null if the filename doesn't match the expected pattern.\n */\nexport function parseSessionTitleChunk(fileName: string): string | null {\n  const m = SESSION_TITLE_RE.exec(fileName);\n  if (!m) return null;\n  const [, num, date, title] = m;\n  return `Session #${num} ${date}: ${title}`;\n}\n\n/** Number of files to process before yielding to the event loop inside indexProject. */\nexport const INDEX_YIELD_EVERY = 10;\n"],"mappings":"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"}

package/dist/hooks/block-sleep-poll.mjs

@@ -7518,32 +7518,57 @@ function sleepUnitMultiplier(unit) {
   return unit === "m" ? 60 : unit === "h" ? 3600 : unit === "d" ? 86400 : 1;
 }
 var SLEEP_SEGMENT_RE = /(?:^|[;&|\n(){]|\bdo\b|\bthen\b)\s*sleep\s+([0-9]+(?:\.[0-9]+)?)([smhd]?)(?=\s*(?:$|[;&|)\n]))/g;
-function longestSleepSecs(command) {
-  let longest = null;
-  for (const m of command.matchAll(SLEEP_SEGMENT_RE)) {
+var LOOP_RE = /\b(for|while|until)\b([^;\n]*)[;\n]\s*do\b([\s\S]*?)\bdone\b/g;
+function sleepSum(text) {
+  let sum = 0;
+  for (const m of text.matchAll(SLEEP_SEGMENT_RE)) {
     const secs = Number(m[1]) * sleepUnitMultiplier(m[2]);
-    if (!Number.isFinite(secs) || secs < SLEEP_FLOOR_SECS) continue;
-    if (longest === null || secs > longest) longest = secs;
+    if (Number.isFinite(secs)) sum += secs;
   }
-  return longest;
+  return sum;
+}
+function forIterations(header) {
+  const words = header.replace(/^\s*\w+\s+in\s+/, "").trim();
+  if (words === header.trim() || /[$`*?]/.test(words)) return null;
+  const range = /^\{(-?\d+)\.\.(-?\d+)\}$/.exec(words);
+  if (range) return Math.abs(Number(range[2]) - Number(range[1])) + 1;
+  return words ? words.split(/\s+/).length : 0;
+}
+function totalSleepSecs(command) {
+  let total = sleepSum(command);
+  for (const m of command.matchAll(LOOP_RE)) {
+    const body = sleepSum(m[3]);
+    if (body === 0) continue;
+    if (m[1] === "for") {
+      const n = forIterations(m[2]);
+      total += n === null ? Math.max(SLEEP_FLOOR_SECS, body) : body * (n - 1);
+    } else if (!/\bkill\s+-0\b/.test(m[2])) {
+      total += SLEEP_FLOOR_SECS;
+    }
+  }
+  return total;
 }
 
 // src/hooks/ts/lib/sleep-poll-gate.ts
 function denyReason(secs, isWorker) {
   const lead = `sleep ${secs}s blocked: do not sleep-poll. `;
   if (isWorker) {
-    return lead + "In a worker, run the long command in the FOREGROUND with a Bash timeout up to 600000 ms. If it can run longer, start it in the background and wait with a foreground loop that ends when the job ends: while kill -0 <pid> 2>/dev/null; do sleep 15; done";
+    return lead + "In a worker, run the long command in the FOREGROUND with a Bash timeout up to 600000 ms and split longer jobs into steps; run_in_background is denied here.";
   }
   return lead + "Run the long command itself with run_in_background: true (the harness notifies when it exits), or wait on a specific condition with a bounded loop under 60s per step.";
 }
+var BACKGROUND_WORKER_REASON = "run_in_background is blocked in a worker: ending your turn ends this process and kills the job, there is no completion notification. Run the command in the FOREGROUND with a Bash timeout up to 600000 ms, and split a longer job into steps that each fit in that.";
 function decideSleepPollGate(input, env) {
   if (input.tool_name && input.tool_name !== "Bash") return { decision: "allow" };
-  if (input.tool_input?.run_in_background === true) return { decision: "allow" };
+  const isWorker = env.PAI_WORKER === "1";
+  if (input.tool_input?.run_in_background === true) {
+    return isWorker ? { decision: "deny", reason: BACKGROUND_WORKER_REASON } : { decision: "allow" };
+  }
   const command = input.tool_input?.command;
   if (typeof command !== "string") return { decision: "allow" };
-  const secs = longestSleepSecs(command);
-  if (secs === null) return { decision: "allow" };
-  return { decision: "deny", reason: denyReason(secs, env.PAI_WORKER === "1") };
+  const secs = totalSleepSecs(command);
+  if (secs < SLEEP_FLOOR_SECS) return { decision: "allow" };
+  return { decision: "deny", reason: denyReason(secs, isWorker) };
 }
 function renderDecision(d) {
   if (d.decision === "allow") {