@paraharness/fs 0.0.0-stage → 0.2.0

package/dist/executors/fs-source-executors.js

@@ -0,0 +1,55 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { enumerateWorkspaceFiles } from './internal/enumerate-workspace-files.js';
+import { extractWorktreeRootAndBaseRef } from './internal/extract-worktree-root-and-base-ref.js';
+import { resolveJailedWorktreePath } from './internal/resolve-jailed-worktree-path.js';
+/**
+ * Loads UTF-8 text and computes a SHA-256 hex digest for an `FsTextSourceNode` (`fs:text-source`).
+ *
+ * Resolves `node.path` against the immutable host repository root when `ctx.scopeHandle` is
+ * omitted, or against `ctx.scopeHandle.worktreePath` when computing in-run grounding diffs (`SPEC.md` §4.3).
+ *
+ * @param {FsTextSourceNode}  node   - Passive text source AST node.
+ * @param {void}              _input - Unused source executor input parameter.
+ * @param {ResolutionContext} ctx    - Source resolution context with optional `scopeHandle`.
+ *
+ * @returns {Promise<ResolvedSourceArtifact<string>>} UTF-8 file text paired with its SHA-256 digest.
+ */
+export async function executeFsTextSource(node, _input, ctx) {
+    const { absolutePath } = resolveJailedWorktreePath(ctx.scopeHandle, node.path, 'read');
+    const content = await readFile(absolutePath, 'utf8');
+    const digest = createHash('sha256').update(content, 'utf8').digest('hex');
+    return Object.freeze({
+        content,
+        digest,
+    });
+}
+/**
+ * Loads all UTF-8 files matching `node.pattern` in lexicographical order for an `FsGlobSourceNode` (`fs:glob-source`).
+ *
+ * Resolves against the host repository root when `ctx.scopeHandle` is omitted, or against
+ * `ctx.scopeHandle.worktreePath` when computing in-run grounding diffs (`SPEC.md` §4.3).
+ *
+ * @param {FsGlobSourceNode}  node   - Passive glob source AST node.
+ * @param {void}              _input - Unused source executor input parameter.
+ * @param {ResolutionContext} ctx    - Source resolution context with optional `scopeHandle`.
+ *
+ * @returns {Promise<ResolvedSourceArtifact<ReadonlyArray<{ readonly path: string; readonly content: string }>>>} Matched `{ path, content }` records paired with their combined SHA-256 digest.
+ */
+export async function executeFsGlobSource(node, _input, ctx) {
+    const { rootPath } = extractWorktreeRootAndBaseRef(ctx.scopeHandle);
+    const matchedRelPaths = await enumerateWorkspaceFiles(rootPath, node.pattern);
+    const entries = [];
+    const hash = createHash('sha256');
+    for (const relPath of matchedRelPaths) {
+        const { absolutePath } = resolveJailedWorktreePath(ctx.scopeHandle, relPath, 'read');
+        const content = await readFile(absolutePath, 'utf8');
+        entries.push(Object.freeze({ path: relPath, content }));
+        hash.update(`${relPath}\0${content}\0`, 'utf8');
+    }
+    return Object.freeze({
+        content: Object.freeze(entries),
+        digest: hash.digest('hex'),
+    });
+}
+//# sourceMappingURL=fs-source-executors.js.map

package/dist/executors/fs-source-executors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-source-executors.js","sourceRoot":"","sources":["../../src/executors/fs-source-executors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAO5C,OAAO,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,EAAE,6BAA6B,EAAE,MAAM,kDAAkD,CAAC;AACjG,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AAEvF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,IAAsB,EACtB,MAAY,EACZ,GAAsB;IAEtB,MAAM,EAAE,YAAY,EAAE,GAAG,yBAAyB,CAAC,GAAG,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACvF,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IACrD,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1E,OAAO,MAAM,CAAC,MAAM,CAAiC;QACnD,OAAO;QACP,MAAM;KACP,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,IAAsB,EACtB,MAAY,EACZ,GAAsB;IAItB,MAAM,EAAE,QAAQ,EAAE,GAAG,6BAA6B,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IACpE,MAAM,eAAe,GAAG,MAAM,uBAAuB,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9E,MAAM,OAAO,GAA+D,EAAE,CAAC;IAC/E,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;IAClC,KAAK,MAAM,OAAO,IAAI,eAAe,EAAE,CAAC;QACtC,MAAM,EAAE,YAAY,EAAE,GAAG,yBAAyB,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QACrF,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QACrD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,CAAC,GAAG,OAAO,KAAK,OAAO,IAAI,EAAE,MAAM,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;QAC/B,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;KAC3B,CAAC,CAAC;AACL,CAAC"}

package/dist/executors/fs-tool-effect.d.ts

@@ -0,0 +1,33 @@
+import type { ToolEffect } from '@paraharness/core';
+/**
+ * Structured filesystem attributes attached to an `FsToolEffect` descriptor.
+ *
+ * Captures the access mode (`'read' | 'write'`), canonicalized worktree-relative POSIX
+ * file paths, base-ref path existence (`existingPathsAtBaseRef`), and post-edit UTF-8
+ * contents (`proposedContent`).
+ */
+export interface FsToolEffectAttributes extends Readonly<Record<string, unknown>> {
+    /** Filesystem access mode (`'read'` for non-mutating reads/searches, `'write'` for edits/writes). */
+    readonly mode: 'read' | 'write';
+    /** Canonicalized worktree-relative POSIX file paths touched by the tool invocation. */
+    readonly paths: readonly string[];
+    /** Subset of `paths` that already existed at `scopeHandle.baseRef` prior to mutation. */
+    readonly existingPathsAtBaseRef?: readonly string[];
+    /** Proposed post-mutation UTF-8 file text keyed by normalized worktree-relative path. */
+    readonly proposedContent?: Readonly<Record<string, string>>;
+}
+/**
+ * Domain-specific `ToolEffect` emitted by `@paraharness/fs` tools and workspace diffs (`SPEC.md` §4.3).
+ *
+ * Sets `kind: 'fs:effect'` and `mutatesScope: true` on write mutations so `ScopeLockManager`,
+ * policy guards, quota tripwires, and telemetry collectors can inspect filesystem operations.
+ */
+export interface FsToolEffect extends ToolEffect {
+    /** Discriminant identifying a filesystem tool effect. */
+    readonly kind: 'fs:effect';
+    /** True when `attributes.mode === 'write'`, acquiring an exclusive scope write lock. */
+    readonly mutatesScope: boolean;
+    /** Structured filesystem effect attributes. */
+    readonly attributes: FsToolEffectAttributes;
+}
+//# sourceMappingURL=fs-tool-effect.d.ts.map

package/dist/executors/fs-tool-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-tool-effect.d.ts","sourceRoot":"","sources":["../../src/executors/fs-tool-effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,WAAW,sBAAuB,SAAQ,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/E,qGAAqG;IACrG,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,uFAAuF;IACvF,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,yFAAyF;IACzF,QAAQ,CAAC,sBAAsB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpD,yFAAyF;IACzF,QAAQ,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC7D;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C,yDAAyD;IACzD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,wFAAwF;IACxF,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,UAAU,EAAE,sBAAsB,CAAC;CAC7C"}

package/dist/executors/fs-tool-effect.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fs-tool-effect.js.map

package/dist/executors/fs-tool-effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-tool-effect.js","sourceRoot":"","sources":["../../src/executors/fs-tool-effect.ts"],"names":[],"mappings":""}

package/dist/executors/fs-write-guard-executors.d.ts

@@ -0,0 +1,55 @@
+import type { FsRequireReadBeforeWriteGuardNode, FsScopedWriteGuardNode, FsSecretLiteralsGuardNode, FsWriteGuardNode, PolicyGuardEvaluationInput, PolicyGuardEvaluationResult, StepExecutionContext } from '@paraharness/core';
+/**
+ * Evaluates an `FsWriteGuardNode` (`fs:write-guard`) against proposed tool effects (`SPEC.md` §3.5 & §4.3).
+ *
+ * Blocks paths matching `node.denyGlobs` unless exempted by `node.allowGlobs` or `input.activeLeases`,
+ * and when `onlyExistingAtBaseRef: true` is configured, restricts denials strictly to files present
+ * in `existingPathsAtBaseRef`.
+ *
+ * @param {FsWriteGuardNode}              node  - Write guard AST node.
+ * @param {PolicyGuardEvaluationInput}    input - Tool name, proposed effects, and active leases.
+ * @param {StepExecutionContext<unknown>} ctx   - Step execution context.
+ *
+ * @returns {PolicyGuardEvaluationResult} Guard evaluation result and projected `violatedEffects`.
+ */
+export declare function evaluateFsWriteGuard(node: FsWriteGuardNode, input: PolicyGuardEvaluationInput, ctx: StepExecutionContext<unknown>): PolicyGuardEvaluationResult;
+/**
+ * Evaluates an `FsRequireReadBeforeWriteGuardNode` (`fs:require-read-before-write`) (`SPEC.md` §4.3).
+ *
+ * Rejects mutating any file that existed at `baseRef` unless `ctx.observedEffects` contains a prior
+ * read effect for that path in the current session.
+ *
+ * @param {FsRequireReadBeforeWriteGuardNode} _node - Read-before-write guard AST node.
+ * @param {PolicyGuardEvaluationInput}        input - Tool name, proposed effects, and active leases.
+ * @param {StepExecutionContext<unknown>}     ctx   - Step execution context providing `observedEffects`.
+ *
+ * @returns {PolicyGuardEvaluationResult} Guard evaluation result and projected `violatedEffects`.
+ */
+export declare function evaluateFsRequireReadBeforeWriteGuard(_node: FsRequireReadBeforeWriteGuardNode, input: PolicyGuardEvaluationInput, ctx: StepExecutionContext<unknown>): PolicyGuardEvaluationResult;
+/**
+ * Evaluates an `FsScopedWriteGuardNode` (`fs:scoped-write`) against `ctx.activePartitions` (`SPEC.md` §4.3).
+ *
+ * Rejects write mutations to any file path outside the union of member `globs` for the actor's
+ * `activePartitions` in `node.partitionMap`.
+ *
+ * @param {FsScopedWriteGuardNode}        node  - Scoped write guard AST node.
+ * @param {PolicyGuardEvaluationInput}    input - Tool name, proposed effects, and active leases.
+ * @param {StepExecutionContext<unknown>} ctx   - Step execution context providing `activePartitions`.
+ *
+ * @returns {PolicyGuardEvaluationResult} Guard evaluation result and projected `violatedEffects`.
+ */
+export declare function evaluateFsScopedWriteGuard(node: FsScopedWriteGuardNode, input: PolicyGuardEvaluationInput, ctx: StepExecutionContext<unknown>): PolicyGuardEvaluationResult;
+/**
+ * Evaluates an `FsSecretLiteralsGuardNode` (`fs:secret-literals`) against `proposedContent` (`SPEC.md` §4.3).
+ *
+ * Scans proposed post-mutation file contents against built-in and custom secret regular expressions
+ * and blocks writes containing secret literals.
+ *
+ * @param {FsSecretLiteralsGuardNode}     node  - Secret literals guard AST node.
+ * @param {PolicyGuardEvaluationInput}    input - Tool name, proposed effects, and active leases.
+ * @param {StepExecutionContext<unknown>} _ctx  - Step execution context.
+ *
+ * @returns {PolicyGuardEvaluationResult} Guard evaluation result and projected `violatedEffects`.
+ */
+export declare function evaluateFsSecretLiteralsGuard(node: FsSecretLiteralsGuardNode, input: PolicyGuardEvaluationInput, _ctx: StepExecutionContext<unknown>): PolicyGuardEvaluationResult;
+//# sourceMappingURL=fs-write-guard-executors.d.ts.map

package/dist/executors/fs-write-guard-executors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-write-guard-executors.d.ts","sourceRoot":"","sources":["../../src/executors/fs-write-guard-executors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EACjC,sBAAsB,EACtB,yBAAyB,EACzB,gBAAgB,EAChB,0BAA0B,EAC1B,2BAA2B,EAC3B,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAU3B;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,0BAA0B,EACjC,GAAG,EAAE,oBAAoB,CAAC,OAAO,CAAC,GACjC,2BAA2B,CAE7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,iCAAiC,EACxC,KAAK,EAAE,0BAA0B,EACjC,GAAG,EAAE,oBAAoB,CAAC,OAAO,CAAC,GACjC,2BAA2B,CAE7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,sBAAsB,EAC5B,KAAK,EAAE,0BAA0B,EACjC,GAAG,EAAE,oBAAoB,CAAC,OAAO,CAAC,GACjC,2BAA2B,CAE7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,yBAAyB,EAC/B,KAAK,EAAE,0BAA0B,EACjC,IAAI,EAAE,oBAAoB,CAAC,OAAO,CAAC,GAClC,2BAA2B,CAE7B"}

package/dist/executors/fs-write-guard-executors.js

@@ -0,0 +1,64 @@
+import { evaluateFsReadBeforeWritePaths, evaluateFsSecretLiteralPaths, } from './internal/evaluate-fs-content-and-read-guards.js';
+import { evaluateFsScopedWritePaths, evaluateFsWriteGuardPaths, } from './internal/evaluate-fs-write-and-boundary-guards.js';
+/**
+ * Evaluates an `FsWriteGuardNode` (`fs:write-guard`) against proposed tool effects (`SPEC.md` §3.5 & §4.3).
+ *
+ * Blocks paths matching `node.denyGlobs` unless exempted by `node.allowGlobs` or `input.activeLeases`,
+ * and when `onlyExistingAtBaseRef: true` is configured, restricts denials strictly to files present
+ * in `existingPathsAtBaseRef`.
+ *
+ * @param {FsWriteGuardNode}              node  - Write guard AST node.
+ * @param {PolicyGuardEvaluationInput}    input - Tool name, proposed effects, and active leases.
+ * @param {StepExecutionContext<unknown>} ctx   - Step execution context.
+ *
+ * @returns {PolicyGuardEvaluationResult} Guard evaluation result and projected `violatedEffects`.
+ */
+export function evaluateFsWriteGuard(node, input, ctx) {
+    return evaluateFsWriteGuardPaths(node, input, ctx);
+}
+/**
+ * Evaluates an `FsRequireReadBeforeWriteGuardNode` (`fs:require-read-before-write`) (`SPEC.md` §4.3).
+ *
+ * Rejects mutating any file that existed at `baseRef` unless `ctx.observedEffects` contains a prior
+ * read effect for that path in the current session.
+ *
+ * @param {FsRequireReadBeforeWriteGuardNode} _node - Read-before-write guard AST node.
+ * @param {PolicyGuardEvaluationInput}        input - Tool name, proposed effects, and active leases.
+ * @param {StepExecutionContext<unknown>}     ctx   - Step execution context providing `observedEffects`.
+ *
+ * @returns {PolicyGuardEvaluationResult} Guard evaluation result and projected `violatedEffects`.
+ */
+export function evaluateFsRequireReadBeforeWriteGuard(_node, input, ctx) {
+    return evaluateFsReadBeforeWritePaths(input, ctx);
+}
+/**
+ * Evaluates an `FsScopedWriteGuardNode` (`fs:scoped-write`) against `ctx.activePartitions` (`SPEC.md` §4.3).
+ *
+ * Rejects write mutations to any file path outside the union of member `globs` for the actor's
+ * `activePartitions` in `node.partitionMap`.
+ *
+ * @param {FsScopedWriteGuardNode}        node  - Scoped write guard AST node.
+ * @param {PolicyGuardEvaluationInput}    input - Tool name, proposed effects, and active leases.
+ * @param {StepExecutionContext<unknown>} ctx   - Step execution context providing `activePartitions`.
+ *
+ * @returns {PolicyGuardEvaluationResult} Guard evaluation result and projected `violatedEffects`.
+ */
+export function evaluateFsScopedWriteGuard(node, input, ctx) {
+    return evaluateFsScopedWritePaths(node, input, ctx);
+}
+/**
+ * Evaluates an `FsSecretLiteralsGuardNode` (`fs:secret-literals`) against `proposedContent` (`SPEC.md` §4.3).
+ *
+ * Scans proposed post-mutation file contents against built-in and custom secret regular expressions
+ * and blocks writes containing secret literals.
+ *
+ * @param {FsSecretLiteralsGuardNode}     node  - Secret literals guard AST node.
+ * @param {PolicyGuardEvaluationInput}    input - Tool name, proposed effects, and active leases.
+ * @param {StepExecutionContext<unknown>} _ctx  - Step execution context.
+ *
+ * @returns {PolicyGuardEvaluationResult} Guard evaluation result and projected `violatedEffects`.
+ */
+export function evaluateFsSecretLiteralsGuard(node, input, _ctx) {
+    return evaluateFsSecretLiteralPaths(node, input);
+}
+//# sourceMappingURL=fs-write-guard-executors.js.map

package/dist/executors/fs-write-guard-executors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-write-guard-executors.js","sourceRoot":"","sources":["../../src/executors/fs-write-guard-executors.ts"],"names":[],"mappings":"AASA,OAAO,EACL,8BAA8B,EAC9B,4BAA4B,GAC7B,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,GAC1B,MAAM,qDAAqD,CAAC;AAE7D;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,oBAAoB,CAClC,IAAsB,EACtB,KAAiC,EACjC,GAAkC;IAElC,OAAO,yBAAyB,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qCAAqC,CACnD,KAAwC,EACxC,KAAiC,EACjC,GAAkC;IAElC,OAAO,8BAA8B,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,0BAA0B,CACxC,IAA4B,EAC5B,KAAiC,EACjC,GAAkC;IAElC,OAAO,0BAA0B,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,6BAA6B,CAC3C,IAA+B,EAC/B,KAAiC,EACjC,IAAmC;IAEnC,OAAO,4BAA4B,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AACnD,CAAC"}

package/dist/executors/fs-write-tool-drivers.d.ts

@@ -0,0 +1,24 @@
+import type { FsEditToolNode, FsWriteToolNode, ToolDriver } from '@paraharness/core';
+/**
+ * Creates the workspace-jailed `ToolDriver` for `FsEditToolNode` (`fs:edit` / `edit_file`).
+ *
+ * Emits synchronous `FsToolEffect` write descriptors (`mutatesScope: true`) populated with
+ * `existingPathsAtBaseRef` and `proposedContent`, and replaces `oldString` with `newString`.
+ *
+ * @template THandle Runtime handle type of the active isolation scope.
+ *
+ * @returns {ToolDriver<FsEditToolNode<THandle>, THandle>} Frozen `fs:edit` tool driver.
+ */
+export declare function createFsEditToolDriver<THandle = unknown>(): ToolDriver<FsEditToolNode<THandle>, THandle>;
+/**
+ * Creates the workspace-jailed `ToolDriver` for `FsWriteToolNode` (`fs:write` / `write_file`).
+ *
+ * Emits synchronous `FsToolEffect` write descriptors (`mutatesScope: true`) populated with
+ * `existingPathsAtBaseRef` and `proposedContent`, and writes UTF-8 text to disk.
+ *
+ * @template THandle Runtime handle type of the active isolation scope.
+ *
+ * @returns {ToolDriver<FsWriteToolNode<THandle>, THandle>} Frozen `fs:write` tool driver.
+ */
+export declare function createFsWriteToolDriver<THandle = unknown>(): ToolDriver<FsWriteToolNode<THandle>, THandle>;
+//# sourceMappingURL=fs-write-tool-drivers.d.ts.map

package/dist/executors/fs-write-tool-drivers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-write-tool-drivers.d.ts","sourceRoot":"","sources":["../../src/executors/fs-write-tool-drivers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EAEf,UAAU,EAGX,MAAM,mBAAmB,CAAC;AAQ3B;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAG,OAAO,KAAK,UAAU,CACrE,cAAc,CAAC,OAAO,CAAC,EACvB,OAAO,CACR,CASA;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,GAAG,OAAO,KAAK,UAAU,CACtE,eAAe,CAAC,OAAO,CAAC,EACxB,OAAO,CACR,CASA"}

package/dist/executors/fs-write-tool-drivers.js

@@ -0,0 +1,44 @@
+import { describeFsEditEffects } from './internal/describe-fs-edit-effects.js';
+import { describeFsWriteEffects } from './internal/describe-fs-write-effects.js';
+import { editFsToolFile, writeFsToolFile, } from './internal/fs-coding-tool-drivers.js';
+/**
+ * Creates the workspace-jailed `ToolDriver` for `FsEditToolNode` (`fs:edit` / `edit_file`).
+ *
+ * Emits synchronous `FsToolEffect` write descriptors (`mutatesScope: true`) populated with
+ * `existingPathsAtBaseRef` and `proposedContent`, and replaces `oldString` with `newString`.
+ *
+ * @template THandle Runtime handle type of the active isolation scope.
+ *
+ * @returns {ToolDriver<FsEditToolNode<THandle>, THandle>} Frozen `fs:edit` tool driver.
+ */
+export function createFsEditToolDriver() {
+    return Object.freeze({
+        describeEffects(_node, args, scopeHandle) {
+            return describeFsEditEffects(scopeHandle, args);
+        },
+        execute(node, args, ctx) {
+            return editFsToolFile(node, args, ctx);
+        },
+    });
+}
+/**
+ * Creates the workspace-jailed `ToolDriver` for `FsWriteToolNode` (`fs:write` / `write_file`).
+ *
+ * Emits synchronous `FsToolEffect` write descriptors (`mutatesScope: true`) populated with
+ * `existingPathsAtBaseRef` and `proposedContent`, and writes UTF-8 text to disk.
+ *
+ * @template THandle Runtime handle type of the active isolation scope.
+ *
+ * @returns {ToolDriver<FsWriteToolNode<THandle>, THandle>} Frozen `fs:write` tool driver.
+ */
+export function createFsWriteToolDriver() {
+    return Object.freeze({
+        describeEffects(_node, args, scopeHandle) {
+            return describeFsWriteEffects(scopeHandle, args);
+        },
+        execute(node, args, ctx) {
+            return writeFsToolFile(node, args, ctx);
+        },
+    });
+}
+//# sourceMappingURL=fs-write-tool-drivers.js.map

package/dist/executors/fs-write-tool-drivers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-write-tool-drivers.js","sourceRoot":"","sources":["../../src/executors/fs-write-tool-drivers.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC/E,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,EACL,cAAc,EACd,eAAe,GAChB,MAAM,sCAAsC,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB;IAIpC,OAAO,MAAM,CAAC,MAAM,CAA+C;QACjE,eAAe,CAAC,KAA8B,EAAE,IAAa,EAAE,WAAoB;YACjF,OAAO,qBAAqB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,CAAC,IAA6B,EAAE,IAAa,EAAE,GAAkC;YACtF,OAAO,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;QACzC,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,uBAAuB;IAIrC,OAAO,MAAM,CAAC,MAAM,CAAgD;QAClE,eAAe,CAAC,KAA+B,EAAE,IAAa,EAAE,WAAoB;YAClF,OAAO,sBAAsB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QACnD,CAAC;QACD,OAAO,CAAC,IAA8B,EAAE,IAAa,EAAE,GAAkC;YACvF,OAAO,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;QAC1C,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/executors/internal/add-mutated-paths-from-effects.d.ts

@@ -0,0 +1,9 @@
+import type { ToolEffect } from '@paraharness/core';
+/**
+ * Adds normalized mutated file paths from `observedEffects` (`mutatesScope === true` or `mode === 'write'`) into `mutated`.
+ *
+ * @param {readonly ToolEffect[]} observedEffects - Tool effects recorded in `StepExecutionContext`.
+ * @param {Set<string>}           mutated         - Mutable set of normalized POSIX paths to populate.
+ */
+export declare function addMutatedPathsFromEffects(observedEffects: readonly ToolEffect[], mutated: Set<string>): void;
+//# sourceMappingURL=add-mutated-paths-from-effects.d.ts.map

package/dist/executors/internal/add-mutated-paths-from-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-mutated-paths-from-effects.d.ts","sourceRoot":"","sources":["../../../src/executors/internal/add-mutated-paths-from-effects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,SAAS,UAAU,EAAE,EACtC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,GACnB,IAAI,CAaN"}

package/dist/executors/internal/add-mutated-paths-from-effects.js

@@ -0,0 +1,24 @@
+/**
+ * Adds normalized mutated file paths from `observedEffects` (`mutatesScope === true` or `mode === 'write'`) into `mutated`.
+ *
+ * @param {readonly ToolEffect[]} observedEffects - Tool effects recorded in `StepExecutionContext`.
+ * @param {Set<string>}           mutated         - Mutable set of normalized POSIX paths to populate.
+ */
+export function addMutatedPathsFromEffects(observedEffects, mutated) {
+    for (const eff of observedEffects) {
+        if (eff.kind !== 'fs:effect')
+            continue;
+        const mode = eff.attributes?.['mode'];
+        if (eff.mutatesScope !== true && mode !== 'write')
+            continue;
+        const paths = eff.attributes?.['paths'];
+        if (!Array.isArray(paths))
+            continue;
+        for (const relPath of paths) {
+            if (typeof relPath === 'string') {
+                mutated.add(relPath.replace(/\\/g, '/').replace(/^\.\//, ''));
+            }
+        }
+    }
+}
+//# sourceMappingURL=add-mutated-paths-from-effects.js.map

package/dist/executors/internal/add-mutated-paths-from-effects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-mutated-paths-from-effects.js","sourceRoot":"","sources":["../../../src/executors/internal/add-mutated-paths-from-effects.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,UAAU,0BAA0B,CACxC,eAAsC,EACtC,OAAoB;IAEpB,KAAK,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;QAClC,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW;YAAE,SAAS;QACvC,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC;QACtC,IAAI,GAAG,CAAC,YAAY,KAAK,IAAI,IAAI,IAAI,KAAK,OAAO;YAAE,SAAS;QAC5D,MAAM,KAAK,GAAG,GAAG,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,CAAC;QACxC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,SAAS;QACpC,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE,CAAC;YAC5B,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAChC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;YAChE,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/executors/internal/check-paths-exist-at-base-ref.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Checks which paths in `relPaths` existed at `scopeHandle.baseRef` via `git cat-file -e <baseRef>:<path>`.
+ *
+ * Falls back to checking workspace file existence when `scopeHandle` does not specify a `baseRef`.
+ *
+ * @param {unknown}           scopeHandle - Active isolation scope handle.
+ * @param {readonly string[]} relPaths    - Normalized worktree-relative POSIX file paths.
+ *
+ * @returns {readonly string[]} Subset of `relPaths` that existed at `baseRef`.
+ */
+export declare function checkPathsExistAtBaseRef(scopeHandle: unknown, relPaths: readonly string[]): readonly string[];
+//# sourceMappingURL=check-paths-exist-at-base-ref.d.ts.map

package/dist/executors/internal/check-paths-exist-at-base-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-paths-exist-at-base-ref.d.ts","sourceRoot":"","sources":["../../../src/executors/internal/check-paths-exist-at-base-ref.ts"],"names":[],"mappings":"AAyCA;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,OAAO,EACpB,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,SAAS,MAAM,EAAE,CAYnB"}

package/dist/executors/internal/check-paths-exist-at-base-ref.js

@@ -0,0 +1,59 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { extractWorktreeRootAndBaseRef } from './extract-worktree-root-and-base-ref.js';
+/**
+ * Tests whether a single normalized relative file path existed at `gitBaseRef` inside `rootPath`.
+ *
+ * Invokes `git cat-file -e <gitBaseRef>:<path>` when `gitBaseRef` is defined,
+ * falling back to `existsSync` on disk when no git `baseRef` is active.
+ *
+ * @param {string}             rootPath       - Worktree or repository root directory path.
+ * @param {string | undefined} gitBaseRef     - Verified git base commit ref, or `undefined` when git metadata or `baseRef` is absent.
+ * @param {string}             normalizedPath - Normalized POSIX relative file path.
+ *
+ * @returns {boolean} True when `normalizedPath` existed at `gitBaseRef`.
+ */
+function doesSinglePathExistAtBaseRef(rootPath, gitBaseRef, normalizedPath) {
+    if (gitBaseRef === undefined) {
+        return existsSync(path.resolve(rootPath, normalizedPath));
+    }
+    try {
+        execFileSync('git', ['cat-file', '-e', `${gitBaseRef}:${normalizedPath}`], {
+            cwd: rootPath,
+            stdio: 'ignore',
+            env: {
+                ...process.env,
+                GIT_OPTIONAL_LOCKS: '0',
+                GIT_CEILING_DIRECTORIES: path.dirname(rootPath),
+            },
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Checks which paths in `relPaths` existed at `scopeHandle.baseRef` via `git cat-file -e <baseRef>:<path>`.
+ *
+ * Falls back to checking workspace file existence when `scopeHandle` does not specify a `baseRef`.
+ *
+ * @param {unknown}           scopeHandle - Active isolation scope handle.
+ * @param {readonly string[]} relPaths    - Normalized worktree-relative POSIX file paths.
+ *
+ * @returns {readonly string[]} Subset of `relPaths` that existed at `baseRef`.
+ */
+export function checkPathsExistAtBaseRef(scopeHandle, relPaths) {
+    const { rootPath, baseRef } = extractWorktreeRootAndBaseRef(scopeHandle);
+    const gitBaseRef = baseRef !== undefined && existsSync(path.join(rootPath, '.git')) ? baseRef : undefined;
+    const existing = [];
+    for (const relPath of relPaths) {
+        const normalizedPath = relPath.replace(/\\/g, '/').replace(/^\.\//, '');
+        if (doesSinglePathExistAtBaseRef(rootPath, gitBaseRef, normalizedPath)) {
+            existing.push(normalizedPath);
+        }
+    }
+    return Object.freeze(existing);
+}
+//# sourceMappingURL=check-paths-exist-at-base-ref.js.map

package/dist/executors/internal/check-paths-exist-at-base-ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-paths-exist-at-base-ref.js","sourceRoot":"","sources":["../../../src/executors/internal/check-paths-exist-at-base-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AAExF;;;;;;;;;;;GAWG;AACH,SAAS,4BAA4B,CACnC,QAAgB,EAChB,UAA8B,EAC9B,cAAsB;IAEtB,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC;IAC5D,CAAC;IACD,IAAI,CAAC;QACH,YAAY,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,IAAI,EAAE,GAAG,UAAU,IAAI,cAAc,EAAE,CAAC,EAAE;YACzE,GAAG,EAAE,QAAQ;YACb,KAAK,EAAE,QAAQ;YACf,GAAG,EAAE;gBACH,GAAG,OAAO,CAAC,GAAG;gBACd,kBAAkB,EAAE,GAAG;gBACvB,uBAAuB,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;aAChD;SACF,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CACtC,WAAoB,EACpB,QAA2B;IAE3B,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,6BAA6B,CAAC,WAAW,CAAC,CAAC;IACzE,MAAM,UAAU,GACd,OAAO,KAAK,SAAS,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IACzF,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACxE,IAAI,4BAA4B,CAAC,QAAQ,EAAE,UAAU,EAAE,cAAc,CAAC,EAAE,CAAC;YACvE,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AACjC,CAAC"}

package/dist/executors/internal/collect-mutated-paths-since-base-ref.d.ts

@@ -0,0 +1,13 @@
+import type { ToolEffect } from '@paraharness/core';
+/**
+ * Collects distinct mutated file paths from `observedEffects` and git working-tree changes since `baseRef`.
+ *
+ * Ensures `fs.regexCheck` inspects only files mutated during the session or since `scopeHandle.baseRef` (`SPEC.md` §4.3).
+ *
+ * @param {readonly ToolEffect[]} observedEffects - Tool effects recorded in `StepExecutionContext`.
+ * @param {unknown}               scopeHandle     - Active isolation scope handle.
+ *
+ * @returns {readonly string[]} Sorted frozen array of distinct mutated worktree-relative POSIX paths.
+ */
+export declare function collectMutatedPathsSinceBaseRef(observedEffects: readonly ToolEffect[], scopeHandle: unknown): readonly string[];
+//# sourceMappingURL=collect-mutated-paths-since-base-ref.d.ts.map

package/dist/executors/internal/collect-mutated-paths-since-base-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-mutated-paths-since-base-ref.d.ts","sourceRoot":"","sources":["../../../src/executors/internal/collect-mutated-paths-since-base-ref.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIpD;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,eAAe,EAAE,SAAS,UAAU,EAAE,EACtC,WAAW,EAAE,OAAO,GACnB,SAAS,MAAM,EAAE,CAuBnB"}

package/dist/executors/internal/collect-mutated-paths-since-base-ref.js

@@ -0,0 +1,42 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { addMutatedPathsFromEffects } from './add-mutated-paths-from-effects.js';
+import { extractWorktreeRootAndBaseRef } from './extract-worktree-root-and-base-ref.js';
+/**
+ * Collects distinct mutated file paths from `observedEffects` and git working-tree changes since `baseRef`.
+ *
+ * Ensures `fs.regexCheck` inspects only files mutated during the session or since `scopeHandle.baseRef` (`SPEC.md` §4.3).
+ *
+ * @param {readonly ToolEffect[]} observedEffects - Tool effects recorded in `StepExecutionContext`.
+ * @param {unknown}               scopeHandle     - Active isolation scope handle.
+ *
+ * @returns {readonly string[]} Sorted frozen array of distinct mutated worktree-relative POSIX paths.
+ */
+export function collectMutatedPathsSinceBaseRef(observedEffects, scopeHandle) {
+    const mutated = new Set();
+    addMutatedPathsFromEffects(observedEffects, mutated);
+    const { rootPath, baseRef } = extractWorktreeRootAndBaseRef(scopeHandle);
+    let gitOutput = '';
+    if (baseRef !== undefined && existsSync(path.join(rootPath, '.git'))) {
+        try {
+            const gitEnv = {
+                ...process.env,
+                GIT_OPTIONAL_LOCKS: '0',
+                GIT_CEILING_DIRECTORIES: path.dirname(rootPath),
+            };
+            const gitOpts = { cwd: rootPath, encoding: 'utf8', stdio: 'pipe', env: gitEnv };
+            gitOutput = `${execFileSync('git', ['diff', '--name-only', baseRef], gitOpts)}\n${execFileSync('git', ['ls-files', '--others', '--exclude-standard'], gitOpts)}`;
+        }
+        catch {
+            gitOutput = '';
+        }
+    }
+    for (const line of gitOutput.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0)
+            mutated.add(trimmed.replace(/\\/g, '/').replace(/^\.\//, ''));
+    }
+    return Object.freeze([...mutated].sort((a, b) => a.localeCompare(b)));
+}
+//# sourceMappingURL=collect-mutated-paths-since-base-ref.js.map

package/dist/executors/internal/collect-mutated-paths-since-base-ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-mutated-paths-since-base-ref.js","sourceRoot":"","sources":["../../../src/executors/internal/collect-mutated-paths-since-base-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AAExF;;;;;;;;;GASG;AACH,MAAM,UAAU,+BAA+B,CAC7C,eAAsC,EACtC,WAAoB;IAEpB,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;IAClC,0BAA0B,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;IACrD,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,6BAA6B,CAAC,WAAW,CAAC,CAAC;IACzE,IAAI,SAAS,GAAG,EAAE,CAAC;IACnB,IAAI,OAAO,KAAK,SAAS,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;QACrE,IAAI,CAAC;YACH,MAAM,MAAM,GAAG;gBACb,GAAG,OAAO,CAAC,GAAG;gBACd,kBAAkB,EAAE,GAAG;gBACvB,uBAAuB,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;aAChD,CAAC;YACF,MAAM,OAAO,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAe,EAAE,KAAK,EAAE,MAAe,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;YAClG,SAAS,GAAG,GAAG,YAAY,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,KAAK,YAAY,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,oBAAoB,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC;QACnK,CAAC;QAAC,MAAM,CAAC;YACP,SAAS,GAAG,EAAE,CAAC;QACjB,CAAC;IACH,CAAC;IACD,KAAK,MAAM,IAAI,IAAI,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5C,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC5B,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IACxF,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxE,CAAC"}

package/dist/executors/internal/collect-read-paths-from-effects.d.ts

@@ -0,0 +1,12 @@
+import type { ToolEffect } from '@paraharness/core';
+/**
+ * Collects the set of normalized file paths read across `observedEffects` (`mode === 'read'`).
+ *
+ * Used by `fs:require-read-before-write` to verify prior read access in the session.
+ *
+ * @param {readonly ToolEffect[]} observedEffects - Previously observed tool effects in the session.
+ *
+ * @returns {ReadonlySet<string>} Set of normalized POSIX paths read so far.
+ */
+export declare function collectReadPathsFromEffects(observedEffects: readonly ToolEffect[]): ReadonlySet<string>;
+//# sourceMappingURL=collect-read-paths-from-effects.d.ts.map

package/dist/executors/internal/collect-read-paths-from-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-read-paths-from-effects.d.ts","sourceRoot":"","sources":["../../../src/executors/internal/collect-read-paths-from-effects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,eAAe,EAAE,SAAS,UAAU,EAAE,GACrC,WAAW,CAAC,MAAM,CAAC,CAarB"}

package/dist/executors/internal/collect-read-paths-from-effects.js

@@ -0,0 +1,26 @@
+/**
+ * Collects the set of normalized file paths read across `observedEffects` (`mode === 'read'`).
+ *
+ * Used by `fs:require-read-before-write` to verify prior read access in the session.
+ *
+ * @param {readonly ToolEffect[]} observedEffects - Previously observed tool effects in the session.
+ *
+ * @returns {ReadonlySet<string>} Set of normalized POSIX paths read so far.
+ */
+export function collectReadPathsFromEffects(observedEffects) {
+    const readPaths = new Set();
+    for (const eff of observedEffects) {
+        if (eff.kind !== 'fs:effect' || eff.attributes?.['mode'] !== 'read')
+            continue;
+        const paths = eff.attributes['paths'];
+        if (!Array.isArray(paths))
+            continue;
+        for (const relPath of paths) {
+            if (typeof relPath === 'string') {
+                readPaths.add(relPath.replace(/\\/g, '/').replace(/^\.\//, ''));
+            }
+        }
+    }
+    return readPaths;
+}
+//# sourceMappingURL=collect-read-paths-from-effects.js.map

package/dist/executors/internal/collect-read-paths-from-effects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-read-paths-from-effects.js","sourceRoot":"","sources":["../../../src/executors/internal/collect-read-paths-from-effects.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,UAAU,2BAA2B,CACzC,eAAsC;IAEtC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU,CAAC;IACpC,KAAK,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;QAClC,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,KAAK,MAAM;YAAE,SAAS;QAC9E,MAAM,KAAK,GAAG,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACtC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,SAAS;QACpC,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE,CAAC;YAC5B,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAChC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;YAClE,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/executors/internal/compile-active-lease-write-matcher.d.ts

@@ -0,0 +1,14 @@
+import type { LeaseDelta } from '@paraharness/core';
+/**
+ * Pre-compiles and memoizes a single write-mode path matcher across all `FsGlobMatcherNode` grants in `activeLeases`.
+ *
+ * Evaluates both exact normalized file paths and `picomatch` glob patterns across all granted matchers (`Rule 4.4`),
+ * caching both per-matcher `matcher.globs` predicates in `CACHED_GLOB_OR_EXACT_MATCHERS` and the composed predicate
+ * in `CACHED_ACTIVE_LEASE_WRITE_MATCHERS`.
+ *
+ * @param {readonly LeaseDelta[]} activeLeases - Active capability leases granted to the actor or loop.
+ *
+ * @returns {(candidatePath: string) => boolean} Reusable synchronous predicate returning `true` when `candidatePath` is leased.
+ */
+export declare function compileActiveLeaseWriteMatcher(activeLeases: readonly LeaseDelta[]): (candidatePath: string) => boolean;
+//# sourceMappingURL=compile-active-lease-write-matcher.d.ts.map

package/dist/executors/internal/compile-active-lease-write-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-active-lease-write-matcher.d.ts","sourceRoot":"","sources":["../../../src/executors/internal/compile-active-lease-write-matcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAyBpD;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAC5C,YAAY,EAAE,SAAS,UAAU,EAAE,GAClC,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAiBpC"}