bantamkit-mcp 0.35.6 → 0.35.8

package/dist/memory/layers.js

@@ -184,8 +184,23 @@ export function loadGrants(projectStore) {
         throw new MemoryValidationError(`invalid memory config ${configPath}: not a file`);
     }
     let data;
+    let text;
     try {
-        data = parseConfigDocument(pyReadText(configPath));
+        text = pyReadText(configPath);
+    }
+    catch (e) {
+        throw new MemoryValidationError(`invalid memory config ${configPath}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // job65/#158: a tab where a YAML token would start is refused BEFORE the reader runs, in
+    // the sentence `load_grants` gives for PyYAML's own refusal of the same byte. The reader
+    // below accepted `[ \t]*` as indentation, so a tab-indented grant list was layered here
+    // and refused at startup by the reference: one config, two verdicts.
+    const tab = firstTokenTab(text);
+    if (tab !== null) {
+        throw new MemoryValidationError(`invalid memory config ${configPath}: ${tabSentence(tab[0], tab[1])}`);
+    }
+    try {
+        data = parseConfigDocument(text);
     }
     catch (e) {
         // `except (yaml.YAMLError, OSError, UnicodeDecodeError)`. `pyReadText` raises the last
@@ -206,12 +221,97 @@ export function loadGrants(projectStore) {
     for (const entry of raw.items) {
         const resolved = pyResolve(pyJoin(pyParent(configPath), entry.value));
         if (!pyIsDir(resolved)) {
-            throw new MemoryValidationError(`granted store does not exist: ${resolved} (from ${configPath})`);
+            // job65/#184: a path that EXISTS but is not a directory is its own sentence; a regular
+            // file used to be called nonexistent. `pyExists` raises for EACCES exactly as `pyIsDir`.
+            const shape = pyExists(resolved) ? 'is not a directory' : 'does not exist';
+            throw new MemoryValidationError(`granted store ${shape}: ${resolved} (from ${configPath})`);
         }
         grants.push(resolved);
     }
     return grants;
 }
+// ------------------------------------------------------------------------- the config
+/**
+ * job65/#158 — the sentence both runtimes give for a tab PyYAML will not scan. Python
+ * rewrites PyYAML's `found character '\t' that cannot start any token` into exactly this,
+ * from the error's own mark; this port finds the same byte with `firstTokenTab`.
+ */
+export function tabSentence(line, column) {
+    return `line ${line}, column ${column}: a tab cannot start a YAML token; indent with spaces`;
+}
+/**
+ * The first tab PyYAML's scanner would refuse, as 1-based `[line, column]`, or `null`.
+ *
+ * MEASURED, not read off the spec: PyYAML 6.0.3's `scan_to_next_token` skips SPACES only, and
+ * a plain scalar stops at a tab, so every tab outside a quoted scalar and outside a comment
+ * is `found character '\t' that cannot start any token` — leading indentation, after `:`,
+ * after `-`, inside `[ ]`, between a value and its comment, trailing, alone on a line, and
+ * after `---`. A tab inside `'...'`/`"..."` or after a ` #` is accepted. The probe battery
+ * is in `.shiftwork/notes-job65/J65-10.md`. A quote OPENS a scalar only where a token can
+ * start (line start, or after a space, `[`, `{` or `,`) — `it's` is a plain scalar — and an
+ * open quote carries across lines, as a flow scalar does.
+ */
+export function firstTokenTab(text) {
+    const lines = text.split('\n');
+    let quote = null;
+    let flow = 0;
+    let plain = false; // inside a plain scalar, where a quote, `[` or ` ` is content
+    let plainIndent = 0; // the indentation of the line that plain scalar started on
+    for (let n = 0; n < lines.length; n += 1) {
+        const line = lines[n];
+        // A plain scalar continues onto a MORE-indented next line (a multi-line plain scalar);
+        // anything else starts a token. An approximation of PyYAML's indent rule.
+        const indent = line.length - line.replace(/^ +/, '').length;
+        if (plain && indent <= plainIndent)
+            plain = false;
+        for (let i = 0; i < line.length; i += 1) {
+            const ch = line[i];
+            if (quote !== null) {
+                if (quote === '"' && ch === '\\')
+                    i += 1;
+                else if (quote === "'" && ch === "'" && line[i + 1] === "'")
+                    i += 1;
+                else if (ch === quote)
+                    quote = null;
+                continue;
+            }
+            if (ch === '\t')
+                return [n + 1, i + 1];
+            const next = line[i + 1] ?? ' ';
+            if (ch === ' ') {
+                if (plain && next === '#')
+                    plain = false;
+                continue;
+            }
+            if (plain) {
+                if (ch === ':' && (next === ' ' || next === '\t' || (flow > 0 && ',[]{}'.includes(next))))
+                    plain = false;
+                else if (flow > 0 && ',[]{}'.includes(ch))
+                    plain = false;
+                else
+                    continue;
+            }
+            // A token starts here.
+            if (ch === '#')
+                break;
+            if (ch === "'" || ch === '"')
+                quote = ch;
+            else if (ch === '[' || ch === '{')
+                flow += 1;
+            else if ((ch === ']' || ch === '}') && flow > 0)
+                flow -= 1;
+            else if (ch === ',' && flow > 0)
+                continue;
+            else if ((ch === '-' || ch === ':' || ch === '?') && (next === ' ' || next === '\t'))
+                continue;
+            else {
+                plain = true;
+                plainIndent = indent;
+            }
+        }
+    }
+    return null;
+}
 class ConfigParseError extends Error {
 }
 function parseConfigDocument(text) {

package/dist/memory/pyyaml.d.ts

@@ -147,9 +147,11 @@ export type PyOrder = {
  *     carried as a must-differ case rather than claimed.
  *   - `yaml` (`!`, `&`, `*`) RAISES, and CPython does NOT agree for all three: `k: !` is a
  *     tag PROPERTY on an empty node in the real scanner and answers `None`, while `&` and
- *     `*` are an anchor and an alias and answer with a `ScannerError`. This codec has no
- *     scanner and sees three plain scalars. All three are must-differ cases; `!` is the one
- *     where CPython answers and this port refuses, and it is written down as that rather
- *     than filed with the other two.
+ *     `*` are an anchor and an alias and answer with a `ScannerError`. All three are
+ *     must-differ cases; `!` is the one where CPython answers and this port refuses, and it
+ *     is written down as that rather than filed with the other two. Since #120 the fact
+ *     codec refuses a value STARTING with any of the three before it reaches this function
+ *     (`REFUSED_INDICATORS` in `factfile.ts`), so the raise a store sees is a
+ *     `FactParseError` naming the indicator; this arm still answers for any other caller.
  */
 export declare function constructPlain(value: string): string | null | PyScalar;

package/dist/memory/pyyaml.js

@@ -832,10 +832,12 @@ function constructTimestamp(raw) {
  *     carried as a must-differ case rather than claimed.
  *   - `yaml` (`!`, `&`, `*`) RAISES, and CPython does NOT agree for all three: `k: !` is a
  *     tag PROPERTY on an empty node in the real scanner and answers `None`, while `&` and
- *     `*` are an anchor and an alias and answer with a `ScannerError`. This codec has no
- *     scanner and sees three plain scalars. All three are must-differ cases; `!` is the one
- *     where CPython answers and this port refuses, and it is written down as that rather
- *     than filed with the other two.
+ *     `*` are an anchor and an alias and answer with a `ScannerError`. All three are
+ *     must-differ cases; `!` is the one where CPython answers and this port refuses, and it
+ *     is written down as that rather than filed with the other two. Since #120 the fact
+ *     codec refuses a value STARTING with any of the three before it reaches this function
+ *     (`REFUSED_INDICATORS` in `factfile.ts`), so the raise a store sees is a
+ *     `FactParseError` naming the indicator; this arm still answers for any other caller.
  */
 export function constructPlain(value) {
     const tag = resolveImplicitTag(value);

package/dist/memory/store.d.ts

@@ -90,6 +90,21 @@ export declare const VALID_TYPES: readonly ["feedback", "project", "reference",
  * `store.DURABLE_TYPES`.
  */
 export declare const DURABLE_TYPES: readonly ["feedback", "user"];
+/**
+ * THE LONGEST NAME A SAVE ACCEPTS (job65/#156): `NAME_MAX_CHARS` in the reference, the same
+ * number. The fact lands as `<name>.md` through `<name>.md.<pid>.<8 hex>.tmp` (#161), so the
+ * name leaves room for that suffix under the 255-byte file-name limit. WAS: no cap, and a
+ * 301-character name came back as a raw `[Errno 63] File name too long: '<absolute path>'`.
+ * `NAME_RE` admits ASCII only, so characters and bytes are one count.
+ */
+export declare const NAME_MAX_CHARS = 128;
+/** `U+XXXX` of the first lone surrogate in `text`, or `null` when it is all text. */
+export declare function loneSurrogate(text: string): string | null;
+/** One fact file left out of a tolerant read, and the store's own sentence for why (#119). */
+export interface SkippedFact {
+    file: string;
+    reason: string;
+}
 export declare const DUPLICATE_JACCARD = 0.5;
 export declare const RECALL_MIN_SCORE_RATIO = 0;
 export declare const MIN_RATIO_RANGE = "recall min-score ratio must be between 0.0 and 1.0";
@@ -318,8 +333,19 @@ export declare class MemoryStore {
      * the failing leaf, or that strerror, would be a divergence manufactured by mkdir's
      * internals. `this.root` is the path the caller named and both sides agree on it, which is
      * what lets one conformance case pin this line byte for byte.
+     *
+     * AMENDED job65/#141: THE SENTENCE ABOVE IS NOW THE "NOT THERE" ARM ONLY. A `chmod 000`
+     * store answered it too, about a directory that exists. The second arm is still an outcome:
+     * the mkdir failed with one of `NOT_WRITABLE_CODES` AND `this.root` is a directory that is
+     * there, and then the refusal is `memory store is not writable: <root>: <strerror>; the
+     * directory exists but cannot be written to, so nothing was written`. The cwd-`/` divergence
+     * measured above is about a root that is NOT there, so it never reaches this arm.
      */
     private ensureDirs;
+    /** `_present`: is `this.root` a directory that is there? "Not allowed to look" is "there". */
+    private present;
+    /** `_unwritable`: one sentence for a store that exists and refused a write (#141). */
+    private unwritable;
     /**
      * Write a fact, or refuse it as a near-duplicate of one already here.
      *
@@ -356,7 +382,7 @@ export declare class MemoryStore {
      * reference's `not 0.0 <= min_ratio <= 1.0` refuses it. That is a real mutant (M7b) and
      * it is killed on both sides.
      */
-    recall(query: string, k?: number | null, stamp?: boolean, minRatio?: number): Fact[];
+    recall(query: string, k?: number | null, stamp?: boolean, minRatio?: number, skipped?: SkippedFact[]): Fact[];
     /**
      * The fact whose `name` field is exactly `name`, or `null`; no scoring, no ranking.
      *
@@ -373,7 +399,7 @@ export declare class MemoryStore {
      * order, which is the order `recall` breaks a tie in. `stamp` dates the hit through
      * `stamp()` exactly as `recall` dates its hits; a miss writes nothing.
      */
-    lookup(name: string, stamp?: boolean): Fact | null;
+    lookup(name: string, stamp?: boolean, skipped?: SkippedFact[]): Fact | null;
     /**
      * `len(store._facts())` at the operator CLI, which is the only caller.
      *
@@ -610,6 +636,18 @@ export declare class MemoryStore {
      * bytes `dream` MEASURES and the bytes the store WRITES are already one function. That is
      * the code-shape difference the Python half had to manufacture, not a behaviour one.
      */
+    /**
+     * Every fact this store can read, and `{file, reason}` for each file it could not.
+     *
+     * THE DECLARED TOLERANT LISTING (job65/#119), `readable_facts` in the reference. One empty,
+     * truncated, non-UTF-8 or unreadable fact file costs that file, not the store: the hook's
+     * SessionStart index and native export read through this, as `Memory.recallOutcome` reads
+     * through `recall(..., skipped)`. A `facts/` that cannot be listed still throws.
+     */
+    readableFacts(): {
+        facts: Fact[];
+        skipped: SkippedFact[];
+    };
     internals(): StoreInternals;
     private factPath;
     private indexLine;
@@ -694,10 +732,11 @@ export declare class MemoryStore {
     /**
      * Every fact on disk, parsed.
      *
-     * The `read_text` is OUTSIDE the try in the reference, so a fact file that is not UTF-8
-     * raises a bare `UnicodeDecodeError` rather than a `malformed fact file …` sentence. That
-     * ordering is reproduced: `pyReadText` raises `PyUnicodeDecodeError` with CPython's own
-     * message and it is not caught here.
+     * AMENDED job65/#159: the `read_text` is now INSIDE the reference's try, so a fact file that
+     * is not UTF-8 is `malformed fact file <name>: 'utf-8' codec can't decode …` — naming the
+     * file — instead of the bare decoder message. `pyReadText` raises `PyUnicodeDecodeError`
+     * with CPython's own text and it is wrapped here; a `PyOSError` from the read still escapes
+     * as itself, as in the reference (`OSError` is not in its `except`).
      *
      * RULING — THE MESSAGE TEXT FOR A MALFORMED FILE. `_facts` interpolates the exception into
      * `malformed fact file {name}: {e}`, and that reaches the model. Three of the four shapes
@@ -712,7 +751,33 @@ export declare class MemoryStore {
      * carried as a must-differ `ruling` case in the conformance suite so it is re-measured on
      * every run instead of asserted once and forgotten.
      */
+    /**
+     * `_facts`: every fact on disk, in `factPaths` order, with two hand-edit shapes tolerated.
+     *
+     * AN UNQUOTED TIMESTAMP IS READ AS ITS `str()` (#121). `yaml.safe_load` hands the reference
+     * a `datetime.date` for `created: 2026-01-01` and a `datetime.datetime` for the longer
+     * forms, while every file the store writes carries the quoted string. `recall` and `save`
+     * never minded, but `compact` sorts `(last_recalled or created, name)` and the sort raised
+     * `'<' not supported between instances of 'datetime.date' and 'str'` the moment one
+     * hand-edited file sat beside a written one — the only remedy the budget refusal names,
+     * dead on the store that named it. The scalar's `text` IS `str(value)` on the reference
+     * (`isoformat()` for a date, `isoformat(' ')` for a datetime), so both runtimes read the
+     * same string and the next write quotes it. Only timestamps are touched: an `int` or `bool`
+     * in these fields is left exactly as the scalar cases in `suites/store.mjs` pin it.
+     *
+     * `findings`, when given, collects one sentence per shape `lint` should name — the coerced
+     * timestamp, and a file whose name is not the fact's (#122) — without throwing, because
+     * every other caller tolerates both. `lint` is the only caller that passes an array.
+     */
+    /**
+     * `skipped`, when given, makes ONE BAD FILE COST THAT FILE (job65/#119): a file that is
+     * malformed or cannot be read is pushed as `{file, reason}` (the sentence this would have
+     * thrown) and every other file is still read. Only `recall`, `lookup` and `readableFacts`
+     * pass it; a save, a compaction or a lint keeps the strict read.
+     */
     private facts;
+    /** One fact file, parsed, or the `malformed fact file` sentence for it (see `facts`). */
+    private readFact;
     /**
      * Date the recall.
      *
@@ -722,7 +787,17 @@ export declare class MemoryStore {
      * listing inside `_facts` has already run before any write.
      */
     private stamp;
-    /** Write via `<name>.md.tmp` and `os.replace`, so a reader never sees a half-written fact. */
+    /**
+     * Write via a PER-WRITER temp and `os.replace`, so a reader never sees a half-written fact
+     * and two writers never share a temp (job65/#161).
+     *
+     * WAS `<name>.md.tmp`, one temp per FACT: two servers saving one name raced on it (the
+     * second `replace` found nothing — `[Errno 2] … 'shared-name.md.tmp'`), and a write that
+     * died half-way left the temp beside the facts. NOW the shape `clockOut` and the hook ledger
+     * use (J65-1, J65-4): `<name>.md.<pid>.<8 hex>.tmp`, created with `wx` (O_EXCL), renamed
+     * onto the fact, and unlinked on any failure before the error goes on up. `*.md` listings
+     * never see it.
+     */
     private writeFact;
     /**
      * Write `index.md` from the facts on disk. THE OP THE ORIGINAL DEFECT DESTROYED.