@cerebriline/core 4.100.274 → 4.100.277

package/dist/runtime/atomic/restore-file-tool.d.ts

@@ -92,7 +92,7 @@ export declare const MAX_RESTORES_PER_TRANSACTION = 27;
  * without leaving the door open on a hundred.
  */
 export declare const MAX_NOOP_RESTORES_PER_TRANSACTION = 3;
-export declare const RESTORE_FILE_TOOL_DESCRIPTION = "Put one file back exactly as it was when this transaction opened, discarding every change you have made to it since.\n\nUse it the moment an edit goes wrong in a way you would otherwise have to undo by hand \u2014 you deleted more than you meant to, you merged two lines together, you have rewritten the same line four times and it is further from working than when you started. Restoring is exact. Retyping the original from memory is not, and on a long or minified line it is where runs go to die.\n\nIt affects one file. Anything you changed in other files this transaction stays. If the file did not exist when the transaction opened, restoring it deletes it.\n\n**You do not have to go all the way back.** Every time a tool writes a file, that version is kept and numbered, and `revision` says which one to return to:\n\n- `revision: \"last\"` undoes only your most recent change to the file, keeping everything before it. This is almost always the one you want after a single edit goes wrong.\n- `revision: \"#3\"` (or `3`) returns to that numbered version. Every edit's result tells you the number it just made, and every read of the file lists the ones you can go back to.\n- `revision: \"original\"` is the file as this transaction opened, which is what you get if you say nothing.\n\nGoing back one step is not the same as starting again. If you have fixed three things and broken the fourth, `last` keeps the three.\n\nThis is not the end of the transaction and it does not spend one \u2014 you carry on, from the file as it was. Read the file again afterwards: its line numbers are back to what they were at that revision, and any range you read earlier no longer addresses the same code.\n\nIf you only want to *see* what the file said before your changes, do not restore it \u2014 call `read_files` with `revision: \"base\"` and it is shown to you with the file left alone.";
+export declare const RESTORE_FILE_TOOL_DESCRIPTION = "Put one file back exactly as it was when this transaction opened, discarding every change you have made to it since.\n\nUse it the moment an edit goes wrong in a way you would otherwise have to undo by hand \u2014 you deleted more than you meant to, you merged two lines together, you have rewritten the same line four times and it is further from working than when you started. Restoring is exact. Retyping the original from memory is not, and on a long or minified line it is where runs go to die.\n\nIt affects one file. Anything you changed in other files this transaction stays. If the file did not exist when the transaction opened, restoring it deletes it.\n\n**You do not have to go all the way back.** Every time a tool writes a file, that version is kept and numbered, and `revision` says which one to return to:\n\n- `revision: \"last\"` undoes only your most recent change to the file, keeping everything before it. This is almost always the one you want after a single edit goes wrong. Asking for it again goes one more step back; it does not undo the restore you just made.\n- `revision: \"#3\"` (or `3`) returns to that numbered version. Every edit's result tells you the number it just made, and every read of the file lists the ones you can go back to.\n- `revision: \"original\"` is the file as this transaction opened, which is what you get if you say nothing.\n\nGoing back one step is not the same as starting again. If you have fixed three things and broken the fourth, `last` keeps the three.\n\nThis is not the end of the transaction and it does not spend one \u2014 you carry on, from the file as it was. Read the file again afterwards: its line numbers are back to what they were at that revision, and any range you read earlier no longer addresses the same code.\n\nIf you only want to *see* what the file said before your changes, do not restore it \u2014 call `read_files` with `revision: \"base\"` and it is shown to you with the file left alone.";
 /**
  * The same tool, described for a session that has no transactions.
  *
@@ -103,7 +103,7 @@ export declare const RESTORE_FILE_TOOL_DESCRIPTION = "Put one file back exactly
  * carries over unchanged is the part that matters — going back is exact and
  * retyping from memory is not.
  */
-export declare const RESTORE_FILE_TOOL_SESSION_DESCRIPTION = "Put one file back to a version of it you had earlier, discarding what you have written to it since.\n\nUse it the moment an edit goes wrong in a way you would otherwise have to undo by hand \u2014 you deleted more than you meant to, you merged two lines together, you replaced the file with something that was never meant to be its contents. Restoring is exact. Retyping the original from memory is not, and on a long or minified line it is where runs go to die.\n\nEvery time a tool writes a file, that version is kept and numbered, and `revision` says which one to return to:\n\n- `revision: \"last\"` undoes only your most recent change to the file, keeping everything before it. This is almost always the one you want after a single edit goes wrong.\n- `revision: \"#3\"` (or `3`) returns to that numbered version. Every edit's result tells you the number it just made, and every read of the file lists the ones you can go back to.\n- `revision: \"original\"` is the file as it stood before this session first wrote to it, which is what you get if you say nothing.\n\nIt affects one file, and only files this session has written: a file nothing has touched has no earlier version held, and this will say so rather than guess.\n\nRead the file again afterwards: its line numbers are back to what they were at that revision, and any range you read earlier no longer addresses the same code.\n\nIf you only want to *see* what the file said before your changes, do not restore it \u2014 call `read_files` with `revision: \"original\"` (or a number) and it is shown to you with the file left alone.";
+export declare const RESTORE_FILE_TOOL_SESSION_DESCRIPTION = "Put one file back to a version of it you had earlier, discarding what you have written to it since.\n\nUse it the moment an edit goes wrong in a way you would otherwise have to undo by hand \u2014 you deleted more than you meant to, you merged two lines together, you replaced the file with something that was never meant to be its contents. Restoring is exact. Retyping the original from memory is not, and on a long or minified line it is where runs go to die.\n\nEvery time a tool writes a file, that version is kept and numbered, and `revision` says which one to return to:\n\n- `revision: \"last\"` undoes only your most recent change to the file, keeping everything before it. This is almost always the one you want after a single edit goes wrong. Asking for it again goes one more step back; it does not undo the restore you just made.\n- `revision: \"#3\"` (or `3`) returns to that numbered version. Every edit's result tells you the number it just made, and every read of the file lists the ones you can go back to.\n- `revision: \"original\"` is the file as it stood before this session first wrote to it, which is what you get if you say nothing.\n\nIt affects one file, and only files this session has written: a file nothing has touched has no earlier version held, and this will say so rather than guess.\n\nRead the file again afterwards: its line numbers are back to what they were at that revision, and any range you read earlier no longer addresses the same code.\n\nIf you only want to *see* what the file said before your changes, do not restore it \u2014 call `read_files` with `revision: \"original\"` (or a number) and it is shown to you with the file left alone.";
 export declare const RESTORE_FILE_TOOL_INPUT_SCHEMA: {
     readonly type: "object";
     readonly properties: {
@@ -113,7 +113,7 @@ export declare const RESTORE_FILE_TOOL_INPUT_SCHEMA: {
         };
         readonly revision: {
             readonly type: "string";
-            readonly description: "Which version to return to: \"last\" to undo only your most recent change to this file, a number such as \"#3\" for that version, or \"original\" for the file as this transaction opened. Defaults to \"original\".";
+            readonly description: "Which version to return to: \"last\" to undo only your most recent change to this file (again, to go one more step back), a number such as \"#3\" for that version, or \"original\" for the earliest version held. Defaults to \"original\".";
         };
         readonly find: {
             readonly type: "string";

package/dist/runtime/atomic/snapshot.d.ts

@@ -23,6 +23,16 @@ export interface Snapshot {
     readonly root: string;
     /** Files that existed but were too large to hold; never rolled back. */
     readonly skipped: readonly string[];
+    /**
+     * Size and modification time of each skipped file that could be statted,
+     * so a restore can say which of them the transaction changed.
+     */
+    readonly skippedStats: ReadonlyMap<string, SkippedStamp>;
+}
+/** Enough of a file's stat to tell that it changed. */
+export interface SkippedStamp {
+    readonly size: number;
+    readonly mtimeMs: number;
 }
 export interface SnapshotLimits {
     /** Most files a snapshot will hold before it gives up on covering the tree. */
@@ -49,6 +59,11 @@ export interface RestoreReport {
     recreated: string[];
     /** Paths the snapshot never held, listed so nobody assumes they reverted. */
     uncovered: string[];
+    /**
+     * Of `uncovered`, the files the transaction changed or deleted: left as the
+     * transaction left them, because there was nothing to put back.
+     */
+    unrestored: string[];
 }
 /**
  * Put the tree back exactly as the snapshot found it.

package/dist/runtime/atomic/stalled-checks.d.ts

@@ -70,8 +70,16 @@ export interface StalledCheckSource {
  */
 export type StalledCheckVerdict = "ok" | "nudge" | "settle";
 export interface StalledChecks {
-    /** Record a check that has just run, and say what it has earned. */
-    checked(passed: boolean): StalledCheckVerdict;
+    /**
+     * Record a check that has just run, and say what it has earned.
+     *
+     * `fingerprint` is what the files held when it ran, when the host can say.
+     * A fingerprint that moved since the last check is a change, whatever made
+     * it: counting only the editing tools let a file rewritten by a shell
+     * command run up the count, and the guard rolled back work that was moving
+     * (automaticum audit 2026-11-08, B10).
+     */
+    checked(passed: boolean, fingerprint?: string): StalledCheckVerdict;
     /** Record a change: whatever the next check says, it is judging new bytes. */
     changed(): void;
     /** The current run of checks over untouched files. */
@@ -98,8 +106,8 @@ export declare function withChangeSignal<T extends AgentToolDefinition>(tools: r
  *
  * It judges nothing and puts nothing back -- saying otherwise would have the
  * model report a transaction that is still open. What it adds is the thing the
- * re-run cannot give it: the check names where the parser gave up, and
- * `check_file` names the line that is actually wrong.
+ * re-run cannot give it: a reading of the whole file rather than the check's
+ * first complaint.
  */
 export declare function describeStalledCheckNudge(runs: number, label: string): string;
 /** What the model is told when the check is closed out from under it. */

package/dist/runtime/atomic/transaction-controller.d.ts

@@ -236,6 +236,9 @@ export declare class TransactionController {
      * files rather than about the clock.
      */
     private readonly checkOutputs;
+    /** The check's most recent output, and the one before it. */
+    private lastCheckOutput?;
+    private previousCheckOutput?;
     private checkHasRepeated;
     /** Set by a carried settlement, so the next `open` keeps the older base. */
     private carrying;
@@ -331,6 +334,13 @@ export declare class TransactionController {
     get pending(): Snapshot | undefined;
     /** The open transaction's per-file history. Empty before the first write. */
     get revisions(): RevisionLog;
+    /**
+     * What the files under the open transaction's root hold right now, as one
+     * string, or nothing when no transaction is open. Two equal fingerprints
+     * mean nothing changed in between, by whatever means -- an edit, a shell
+     * command, another agent.
+     */
+    fingerprint(): Promise<string | undefined>;
     /** Whether the open transaction has changed anything on disk. */
     isUntouched(): Promise<boolean>;
     /**

package/dist/runtime/atomic/unparseable-change.d.ts

@@ -32,4 +32,6 @@ export interface ChangedFile {
  * reasons far more often than for a bracket, and a verdict that guessed would
  * be worse than one that stayed quiet.
  */
-export declare function describeUnparseableChange(changed: readonly ChangedFile[], root: string): string | null;
+export declare function describeUnparseableChange(changed: readonly ChangedFile[], root: string, 
+/** The work is carried into the next transaction rather than put back. */
+carried?: boolean): string | null;

package/dist/runtime/safety/loop-detection.d.ts

@@ -180,7 +180,21 @@ export interface LoopDetectionCall {
 export declare class LoopDetectionTracker {
     private readonly config;
     private readonly state;
-    constructor(config?: Partial<LoopDetectionConfig>);
+    /** Where relative paths in a call resolve, to see whether they changed. */
+    private readonly root;
+    /**
+     * The files a failed or no-op call named, as they were when it was judged.
+     * The verdicts said "nothing has changed, so neither will the result"; a
+     * write the tracker never sees -- a shell `sed -i`, a rollback, the user --
+     * made that false, and the call that would now work was stopped.
+     */
+    private readonly stamps;
+    private pendingSpelled;
+    constructor(config?: Partial<LoopDetectionConfig>, options?: {
+        root?: string;
+    });
+    /** Drop what was concluded about one call, so it is judged afresh. */
+    private forgetVerdicts;
     inspect(call: LoopDetectionCall): LoopDetectionVerdict;
     /**
      * Attribute an outcome to the call `inspect()` last saw.

package/dist/services/global-settings.d.ts

@@ -26,14 +26,14 @@ export declare const GlobalSettingsSchema: z.ZodPipe<z.ZodObject<{
     }>>>;
     toolAutoApprove: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
     tuiTheme: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    disabledTools: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
+    disabledTools: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>, unknown>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
     tools: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
         web_search: "web_search";
     }> & z.core.$partial, z.ZodObject<{
         enabled: z.ZodBoolean;
     }, z.core.$strip>>>;
-    disabledPlugins: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
-    disabledAgentPlugins: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
+    disabledPlugins: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>, unknown>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
+    disabledAgentPlugins: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>, unknown>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
     bundledSkills: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         enabled: z.ZodBoolean;
     }, z.core.$strip>>>>;

package/dist/services/retrieval/memory.d.ts

@@ -47,6 +47,15 @@ export type RememberOutcome =
 export declare const NEAR_DUPLICATE_SIMILARITY = 0.85;
 /** How alike two notes read, 0 to 1: the share of letter pairs they have in common. */
 export declare function noteSimilarity(a: string, b: string): number;
+/**
+ * Whether one note negates what the other says: their negations differ.
+ *
+ * {@link noteSimilarity} counts letter pairs, so "the cache is enabled" and
+ * "the cache is not enabled" score far above the duplicate bar, and the
+ * correction was refused as saying "nearly the same" (automaticum audit
+ * 2026-11-08, rest N6). A pair that differs here is never a duplicate.
+ */
+export declare function negationDiffers(a: string, b: string): boolean;
 export interface RecalledMemory extends MemoryItem {
     /** The reranker's score, 0 to 1, when there was one. */
     relevance?: number;

package/dist/services/sdd/sdd-engine.d.ts

@@ -26,6 +26,17 @@ export type SliceStatus = "pending" | "done";
 export type TaskStatus = "pending" | "in_progress" | "done" | "blocked";
 export type Verdict = "pass" | "needs_remediation";
 export type UatResult = "pass" | "fail" | "needs_human";
+/**
+ * A UAT result as a model writes it, or undefined when it is none of the
+ * three. "failed", "FAIL" and "needs human" were not "fail", so a failed
+ * check closed the slice (automaticum audit 2026-11-08, rest C1).
+ */
+export declare function parseUatResult(value: string | undefined): UatResult | undefined;
+/**
+ * Whether verify output reports failures: "1 failing", "3 failed", "FAIL".
+ * A count of zero does not, and neither does a word inside another.
+ */
+export declare function reportsFailure(evidence: string): boolean;
 export interface SddRequirement {
     id: string;
     title: string;
@@ -231,7 +242,9 @@ export declare class SddEngine {
             result: UatResult;
             note?: string;
         }[];
-    }): void;
+    }): {
+        awaitingPerson: string[];
+    };
     validateMilestone(input: {
         verdict: Verdict;
         findings: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cerebriline/core",
 	"description": "Cerebriline Core SDK for Node Runtime",
-	"version": "4.100.274",
+	"version": "4.100.277",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/mann1x/cline.git",
@@ -72,24 +72,28 @@
 		"node-machine-id": "^1.1.12",
 		"officeparser": "8.0.0",
 		"pdfjs-dist": "6.2.108",
-		"simple-git": "3.36.0",
+		"simple-git": "4.0.2",
 		"tesseract.js": "7.0.0",
 		"tree-sitter-wasms": "^0.1.12",
 		"turndown": "7.2.0",
 		"web-tree-sitter": "^0.25.0",
 		"ws": "^8.20.0",
 		"yaml": "^2.8.2",
-		"zod": "4.4.3",
-		"@cerebriline/agents": "4.100.274",
-		"@cerebriline/llms": "4.100.274",
-		"@cerebriline/shared": "4.100.274"
+		"zod": "4.6.7",
+		"@cerebriline/agents": "4.100.277",
+		"@cerebriline/llms": "4.100.277",
+		"@cerebriline/shared": "4.100.277"
 	},
 	"peerDependencies": {
-		"posthog-node": "^5.8.0"
+		"posthog-node": "^5.8.0",
+		"puppeteer-core": "^23.4.0"
 	},
 	"peerDependenciesMeta": {
 		"posthog-node": {
 			"optional": true
+		},
+		"puppeteer-core": {
+			"optional": true
 		}
 	},
 	"engines": {