@quantiya/codevibe-core 2.0.82 → 2.0.84

package/dist/local-executor/workspace-materializer.d.ts

@@ -9,6 +9,14 @@ export interface WorkspaceMaterializerSession {
     copyFile(source: string, destination: string, maxLogicalBytes?: number): Promise<MaterializedFileMetadata>;
     hashDestinationFile(destination: string, maxBytes: number): Promise<MaterializedFileMetadata>;
     relocateDestinationRoot(authority: WorkspaceRootAuthority): Promise<void>;
+    /**
+     * §5.3 (macOS): clone every listed regular file of one directory with a single `cp -c`, so each later
+     * `copyFile` for those names publishes and verifies a prepared clone instead of spawning `cp` itself. Returns how
+     * many were prepared; 0 (not darwin, forced physical, or the volume refused) leaves the per-file path unchanged.
+     */
+    prepareDarwinClones(relativeDir: string, names: readonly string[]): Promise<number>;
+    /** Remove any staging this directory still holds. MUST run after the directory's files, success or failure. */
+    finishDarwinClones(relativeDir: string): Promise<void>;
     close(): Promise<void>;
 }
 export interface WorkspaceFileHashSession {
@@ -26,6 +34,12 @@ export interface WorkspaceMaterializerOptions {
     priorPhysicalCopyBytes?: number;
     maxFileBytes: number;
     maxTotalBytes: number;
+    /**
+     * Upper bound on a `hashDestinationFile` read. Separate from `maxTotalBytes`, which bounds PHYSICAL copy bytes:
+     * they shared one value, so §5.6's free-space budget — which can be smaller than a tracked file's hashing limit
+     * on a nearly full disk — rejected every hash request. Omitted, the shipped coupling is kept.
+     */
+    maxHashBytes?: number;
     helperTimeoutMs?: number;
     forcePhysicalCopy?: boolean;
     testHangStage?: (source: string) => MaterializationHangStage | undefined;
@@ -33,6 +47,22 @@ export interface WorkspaceMaterializerOptions {
     releasePhysicalBytes?: (bytes: number) => Promise<void> | void;
     beforePhysicalCopy?: (source: string) => Promise<void>;
     onPhysicalCopyBytes?: (totalBytes: number) => Promise<void>;
+    /**
+     * P63 SB-45: the physical-copy ledger shared by every lane of a {@link createWorkspaceMaterializerPool}. Absent, the
+     * session keeps its own, exactly as before.
+     */
+    sharedPhysicalAccounting?: SharedPhysicalAccounting;
+}
+/**
+ * The physical bytes every lane of one snapshot has committed, plus those reserved by copies still in flight. One
+ * object per snapshot; JavaScript runs each reservation's check-and-add without yielding, so concurrent lanes can
+ * never jointly exceed `maxTotalBytes` — each helper only sees the total as of its own request.
+ */
+export interface SharedPhysicalAccounting {
+    committed: number;
+    inflight: number;
+    /** Serializes `onPhysicalCopyBytes` (the durable owner anchor): each write records the CURRENT total. */
+    report: Promise<void>;
 }
 /**
  * One bounded helper owns all live-workspace clone/read waits for a snapshot.
@@ -40,6 +70,28 @@ export interface WorkspaceMaterializerOptions {
  * physical fallback only after the helper reports the exact stable file size.
  */
 export declare function createWorkspaceMaterializerSession(opts: WorkspaceMaterializerOptions): WorkspaceMaterializerSession;
+/**
+ * P63 SB-45: several identity-bound helpers for ONE snapshot, so per-file work runs in parallel. Each lane is an
+ * ordinary {@link WorkspaceMaterializerSession} — the same helper, the same per-file checks, one request at a time —
+ * and the lanes share one physical-copy ledger ({@link SharedPhysicalAccounting}). A caller binds work that
+ * shares helper state to one lane: a directory's batch clones are prepared, adopted and finished by the same lane.
+ * Lanes start lazily, so a small folder starts only the lanes it uses.
+ */
+export interface WorkspaceMaterializerPool {
+    readonly lanes: readonly WorkspaceMaterializerSession[];
+    /** Relocate every lane (after atomic exposure renames the destination root). */
+    relocateDestinationRoot(authority: WorkspaceRootAuthority): Promise<void>;
+    /**
+     * Run `work` for each item on the lanes, at most one request per lane at a time; at most `lanesFor(items)` lanes
+     * are used. Rejects with the first failure only after every started item has settled, so no helper request is
+     * still running when the caller closes the pool.
+     */
+    forEach<T>(items: readonly T[], work: (lane: WorkspaceMaterializerSession, item: T) => Promise<void>): Promise<void>;
+    close(): Promise<void>;
+}
+/** Items per lane before another lane is worth its helper start (~50 ms each). */
+export declare const MATERIALIZER_ITEMS_PER_LANE = 256;
+export declare function createWorkspaceMaterializerPool(opts: WorkspaceMaterializerOptions, laneCount: number): WorkspaceMaterializerPool;
 /**
  * Reuse one identity-bound helper for a full snapshot scan. This retains the
  * same per-file path/inode/hash checks as `anchoredHashFileWithinRoot` without

package/dist/local-executor/workspace-shadow.d.ts

@@ -3,7 +3,7 @@ import { type ProcessCleanupOwner } from './process-tree';
 import { type WorkspaceRootAuthority } from './workspace-authority';
 import { ReviewedShadowDiffFile, ShadowDiffFile, ShadowEnv, ShadowPromoteState, TrackBranchSpec, UnresolvedBundlePublicationRetention } from './shadow-protocol';
 import { RecoveredShadow } from './shadow-recovery';
-export { MAX_TRACKED_FILE_LOGICAL_BYTES, MAX_TRACKED_WORKSPACE_LOGICAL_BYTES, MAX_TRACKED_FILE_COUNT, MAX_TRACKED_PATH_BYTES, MAX_REVIEW_FILE_BYTES, MAX_PROMOTION_PREIMAGE_AGGREGATE_BYTES, MAX_STATE_MARKER_BYTES, DEFAULT_SHADOW_TTL_MS, } from './shadow-protocol';
+export { MAX_CHANGE_SET_FILE_COUNT, MAX_CHANGE_SET_PATH_BYTES, MAX_TRACKED_FILE_LOGICAL_BYTES, MAX_TRACKED_WORKSPACE_LOGICAL_BYTES, MAX_TRACKED_FILE_COUNT, MAX_TRACKED_PATH_BYTES, MAX_REVIEW_FILE_BYTES, MAX_PROMOTION_PREIMAGE_AGGREGATE_BYTES, MAX_STATE_MARKER_BYTES, DEFAULT_SHADOW_TTL_MS, } from './shadow-protocol';
 export type { ShadowChangeKind, ShadowDiffFile, ReviewedShadowDiffFile, CasHelperCrashStage, UnresolvedBundlePublicationRetention, ShadowEnv, TrackBranchSpec, } from './shadow-protocol';
 export { listRecoverableShadows, reconcileShadowPublicationAuthority, listShadowCleanupResidue, assertPathCollectionBounds, } from './shadow-recovery';
 export type { RecoveredShadow, ShadowCleanupResidue } from './shadow-recovery';
@@ -56,6 +56,22 @@ export declare class WorkspaceShadow {
     private readonly stateFileWriteAdmissions;
     private exposureFileAuthority?;
     private stateResourcesRetiredInProcess;
+    /** §5.2/§5.6: where this instance's immutable baseline lives when it is too large to inline. */
+    private baselineRecord?;
+    /** Stage 2 R1-F1: baseline paths set since the shards were written — persisted as `baselineDelta`. */
+    private readonly baselineSetAfterRecord;
+    /**
+     * §7.1: each copy file's stat tuple, recorded at create before the agent ran. Absent for a reopened or
+     * recovered instance — capture then hashes every file, exactly as before.
+     */
+    private copyStatTable?;
+    /** §7.4: the user's own changes to their folder since the start record, from the last capture. */
+    userFolderChanges?: import('./shadow-start-record').FolderChangesSinceStart;
+    /**
+     * §7.4: count the user's own edits to their folder since the task started. Reviewers see this in Slice 2's review
+     * INDEX; Slice 1 records it and writes it to the task log. Never fails a capture: the count is information.
+     */
+    private recordUserFolderChanges;
     private readonly env;
     private readonly maxStateMarkerBytes;
     private promotedInProcess;
@@ -271,6 +287,12 @@ export declare class WorkspaceShadow {
      * retries may consume it, but no marker writer may replace it.
      */
     private beginDisposal;
+    /**
+     * Stage 2 R1-F1: the baseline entries the immutable shards do not hold — paths set after they were written, by this
+     * instance or (after a reopen) by an earlier one, as the existing marker's delta records. Every marker writer
+     * persists it; `undefined` when there are no shards or nothing was added.
+     */
+    private baselineDeltaFor;
     private writeStateMarker;
     private readStateMarker;
     private readStateMarkerSnapshot;