@quantiya/codevibe-claude-plugin 2.0.42 → 2.0.43

package/node_modules/@quantiya/codevibe-core/dist/local-executor/class-b-consumer.d.ts

@@ -193,11 +193,11 @@ export interface ClassBConsumerDeps {
      * CP-12 W2.b (§3.C.2 / H1) — `envelopeTaskId` carries the OUTER Class-B
      * envelope's `task_id` (the `GateDispatchPayload` has none), so the team
      * quorum loop can route the round-0 dispatch to the right per-track `task_id`.
-     * The engine stamps this on EVERY gate dispatch — single-impl INCLUDED (it
-     * equals the loop's single active task). The quorum loop discriminates team vs
-     * single-impl by `envelopeTaskId !== activeTaskId`, NOT by presence, so a
-     * single-impl dispatch (envelopeTaskId === activeTaskId) falls back to the
-     * single active task — byte-identical to today. Mirrors the
+     * The engine stamps this on EVERY gate dispatch — single tasks INCLUDED. P46a
+     * B1: the quorum loop routes ONLY by this id — a single task it knows
+     * (`singleTaskContextByTask`) takes the single path, any other id the team
+     * path, and an empty id buffers for a START still in flight (else it is a
+     * no-op left to recovery). Mirrors the
      * `notifyPolicyRejection(.., rejectedTaskId?)` precedent.
      */
     gateDispatch?: (payload: GateDispatchPayload, envelopeTaskId?: string) => Promise<void>;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/hook-bridge.d.ts

@@ -30,7 +30,7 @@ export declare class HookBridge {
         refusedMessageId: string;
         shellContent: string;
         shellMetadata?: Record<string, unknown>;
-    }): Promise<void>;
+    }, taskCtx?: ClassAEmitterContext | null): Promise<void>;
     private contextOrNull;
     /** @internal */
     get adapterForTests(): AgentKind;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/local-executor-impl.d.ts

@@ -446,8 +446,23 @@ export interface LocalExecutorImplDeps {
 }
 export declare function makeEmptyScope(): AuthorityScope;
 export declare class LocalExecutorImpl implements LocalExecutor {
-    private scope;
-    private taskId;
+    /**
+     * P46a B2 — the SEEDED authority scope (the desktop's static command
+     * allowlist, no paths): what every spawn runs under until ITS task's
+     * TaskAuthorized arrives, what a task-less caller gets, and what
+     * `authorityScope()` reports (unchanged at wiring — its only production
+     * caller freezes it there). Never mutated by a TaskAuthorized.
+     */
+    private baseScope;
+    /**
+     * P46a B2 — PER-TASK authority scopes: each task's TaskAuthorized path scope
+     * merged over the seeded scope (`mergeAuthorityScope`), keyed by task id. A
+     * spawn reads its OWN task's scope, never a union; authority never
+     * accumulates across tasks. Replaces the singleton `this.scope`/`this.taskId`
+     * pair, which made the SECOND concurrent task's spawn run under the FIRST
+     * task's authorized paths (and mis-attributed its audit context).
+     */
+    private readonly scopeByTask;
     private readonly emitter;
     private readonly trackProgressEmitter?;
     private readonly bridge;
@@ -508,20 +523,33 @@ export declare class LocalExecutorImpl implements LocalExecutor {
      * is responsible for routing to `bridgeAuthorityErrorToShellRefusal` /
      * `HookBridge.bridgeAuthorityRefusal` per LOCK #C4-3.
      */
-    enforceAuthority(action: AuthorityAction): Promise<void>;
+    enforceAuthority(action: AuthorityAction, taskId?: string | null): Promise<void>;
     /**
-     * Read-only view of the current authority scope per master §9:1286.
+     * P46a B2 — resolve the authority scope a caller runs under: the task's OWN
+     * merged scope once ITS TaskAuthorized arrived, else the seeded scope (before
+     * authorization, for a task this executor never saw authorized, and for a
+     * task-less caller). Never a union across tasks.
+     */
+    private scopeFor;
+    /**
+     * Read-only view of the SEEDED authority scope per master §9:1286 (P46a B2:
+     * `authorityScope()` keeps today's value at its only production caller — the
+     * continuation writer's clamp, frozen at wiring — which IS the seeded scope).
      * Returns a deep-frozen copy so callers cannot mutate the LE's state.
      */
     authorityScope(): Readonly<AuthorityScope>;
-    enforceCommand(argv: string[]): void;
-    enforceNetwork(): void;
-    enforceWrite(p: string): Promise<string>;
-    enforceRead(p: string): Promise<string>;
-    safeWriteFile(p: string, data: Buffer | string): Promise<void>;
+    /** P46a B2 (Stage 1 r1 F7) — drop a task's merged scope when the task ends. */
+    forgetTaskScope(taskId: string): void;
+    /** P46a B2 — read-only view of ONE task's merged scope (the seeded scope when unauthorized). */
+    authorityScopeForTask(taskId: string): Readonly<AuthorityScope>;
+    enforceCommand(argv: string[], taskId?: string | null): void;
+    enforceNetwork(taskId?: string | null): void;
+    enforceWrite(p: string, taskId?: string | null): Promise<string>;
+    enforceRead(p: string, taskId?: string | null): Promise<string>;
+    safeWriteFile(p: string, data: Buffer | string, taskId?: string | null): Promise<void>;
     safeReadFile(p: string, opts?: {
         encoding?: BufferEncoding;
-    }): Promise<string | Buffer>;
+    }, taskId?: string | null): Promise<string | Buffer>;
     spawnImplementor(args: SpawnArgs): Promise<ImplementorHandle>;
     spawnReviewer(_args: SpawnArgs): Promise<ReviewerHandle>;
     spawnHealthProbe(args: SpawnArgs): Promise<ProbeHandle>;
@@ -848,10 +876,15 @@ export declare class LocalExecutorImpl implements LocalExecutor {
      * carries a strict-monotonic `started_at`; `attemptEnd`/pass/fail carry `ended_at`.
      */
     private emitMergeGateStatus;
-    /** Set the active taskId (production: CP-1.e on TASK_AUTHORIZED). */
-    setActiveTaskId(taskId: string | null): void;
-    /** Replace the active authority scope (production: CP-1.e on TASK_AUTHORIZED). */
+    /**
+     * Replace the SEEDED authority scope (test seam; production seeds it at
+     * construction via `initialScope`). P46a B2: per-task scopes are set only by
+     * a TaskAuthorized (`advanceAuthorityScope`) — use `setAuthorityScopeForTask`
+     * to simulate one in tests.
+     */
     setAuthorityScope(scope: AuthorityScope): void;
+    /** P46a B2 test seam — install ONE task's merged scope as a TaskAuthorized would. */
+    setAuthorityScopeForTask(taskId: string, scope: AuthorityScope): void;
     /** Expose emitter for §8.5 integration test introspection. */
     get emitterForTests(): ClassAEmitter;
     /** CP-12 W2.b — expose the per-track registry for idempotency introspection. */
@@ -860,15 +893,14 @@ export declare class LocalExecutorImpl implements LocalExecutor {
     get trackPayloadCountForTests(): number;
     /** @internal recurring lease owner count. */
     get trackHeartbeatCountForTests(): number;
-    private contextOrNull;
     /**
      * Context resolver for ClassBConsumer emit paths (refusals + PolicyRejection).
-     * Class B inbound packets MAY arrive before a TaskAuthorized has set
-     * `this.taskId` (in fact, TaskAuthorized is the variant that SETS it). For
-     * the signature_invalid / ulid_replay / policy_rejection / malformed
-     * refusal-audit emit path we still need a valid envelope context, so we
-     * fall back to `pending` when no task is active. CP-2 may refine this; for
-     * CP-1.e the audit emit always succeeds with a deterministic placeholder.
+     * Class B inbound packets carry no task the executor could attribute a
+     * refusal to before they are verified (signature_invalid / ulid_replay /
+     * policy_rejection / malformed), and P46a B2 removed the singleton task id,
+     * so the refusal-audit emit uses the deterministic `pending` placeholder —
+     * never another task's id. Spawn-attributed emits resolve their task from
+     * the per-spawn `args.taskId` (`lifecycleCtx`).
      */
     private contextOrFallback;
 }

package/node_modules/@quantiya/codevibe-core/dist/local-executor/types.d.ts

@@ -412,9 +412,14 @@ export interface LocalExecutor {
      * `enforceRead` / `enforceNetwork` / `enforceCommand` based on `action.kind`.
      * Throws `AuthorityError` on refusal (master §9:1284).
      */
-    enforceAuthority(action: AuthorityAction): Promise<void>;
+    enforceAuthority(action: AuthorityAction, taskId?: string | null): Promise<void>;
+    /** P46a B2 — release a task's merged authority scope once the task has ended (optional; Stage 1 r1 F7). */
+    forgetTaskScope?(taskId: string): void;
     ingestHookEvent(event: HookEvent): Promise<void>;
-    /** Read-only view of the current TASK_AUTHORIZED.authorityScope. */
+    /**
+     * Read-only view of the SEEDED authority scope (P46a B2: per-task authorized
+     * scopes live on the executor keyed by task id; "no task" means this scope).
+     */
     authorityScope(): Readonly<AuthorityScope>;
     /**
      * CP-1.c STUB; CP-1.e wires real AppSync subscription + signature verification.

package/node_modules/@quantiya/codevibe-core/dist/local-executor/workspace-shadow.d.ts

@@ -124,6 +124,22 @@ export declare class WorkspaceShadow {
      * authority; completion/discard removes the instance marker with the copy.
      */
     persistReviewedDiff(diff: readonly ShadowDiffFile[]): Promise<void>;
+    /**
+     * P46a C1 — the real tree's current content-hash + mode for a workspace-
+     * relative path, read exactly as the promote compare-and-set reads it
+     * (`readRealFileMetadata`; `{ hash: null, mode: null }` when absent). Used to
+     * record a promoted path's post-image and to attribute a later collision.
+     */
+    readRealMetadata(rel: string): Promise<{
+        hash: string | null;
+        mode: number | null;
+    }>;
+    /**
+     * P46a C2 — the real tree's current text content for a workspace-relative
+     * path (`null` when absent), for the retry brief's "files changed since your
+     * first attempt" diff. Bounded by `MAX_REVIEW_FILE_BYTES`; never logged.
+     */
+    readRealFileText(rel: string): Promise<string | null>;
     /** Read the crash-durable reviewed artifact, or null for an unreviewed snapshot. */
     readReviewedDiff(): Promise<ShadowDiffFile[] | null>;
     /**