@quantiya/codevibe-claude-plugin 2.0.44 → 2.0.46

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

@@ -1,7 +1,7 @@
 import type { AuthorityScope } from './authority';
 import { ClassAEmitter, ClassAEmitterContext } from './class-a-emit';
 import { EmitShellEventFn } from './hook-bridge';
-import { ClassBInbound, GateDispatchPayload, MergeGateDispatchPayload, ReviewerDispatchPayload, ReviseFeedbackPayload, TaskGroupHaltedPayload, TrackAssignedPayload } from './types';
+import { ClassBInbound, GateDispatchPayload, MergeGateDispatchPayload, QueuedWorkEndedPayload, ReviewerDispatchPayload, ReviseFeedbackPayload, TaskGroupHaltedPayload, TrackAssignedPayload } from './types';
 import type { ContinuationPacketWriter } from '../continuation/packet-writer';
 import type { PacketWriteInput } from '../continuation/types';
 export type ClassBVerificationResult = {
@@ -75,6 +75,7 @@ export declare function normalizeTrackAssignedWire(raw: unknown): Partial<TrackA
  * LOCK #E3-1, so an invalid packet is dropped, never surfaced as an exception.
  */
 export declare function isValidTrackAssignedPayload(payload: Partial<TrackAssignedPayload> | undefined): payload is TrackAssignedPayload;
+export declare function isValidQueuedWorkEndedPayload(payload: Partial<QueuedWorkEndedPayload> | undefined): payload is QueuedWorkEndedPayload;
 export interface ClassBConsumerState {
     /** Last received PlannerDecisionApproved per taskId; CP-2 reads. */
     plannerDecisionByTask: Map<string, Extract<ClassBInbound, {
@@ -216,6 +217,13 @@ export interface ClassBConsumerDeps {
      * sweeper re-emit after a crash is idempotent.
      */
     runReviseRound?: (payload: ReviseFeedbackPayload) => Promise<void>;
+    /**
+     * P46b §3.6 — a single task that never started was halted and its slot ended
+     * (`queued_task_expired` / `tier_changed` / `user_cancelled_queued_task`). The
+     * shell marks it `cancelled (reason)` on its first change. When OMITTED
+     * (non-loop LE / tests) the kind is dropped + logged.
+     */
+    queuedWorkEnded?: (payload: QueuedWorkEndedPayload) => Promise<void>;
 }
 /**
  * Class B inbound consumer per design §6.1.
@@ -253,6 +261,7 @@ export declare class ClassBConsumer {
     private handleTaskGroupHalted;
     private handleReviewerDispatch;
     private handleReviseFeedback;
+    private handleQueuedWorkEnded;
     /**
      * Constructs an AuthorityRefusal with one of the LOCK #E4-1 widened category
      * literals and emits an EXECUTOR_REFUSAL via the CP-1.c emitter. Audit-only:

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

@@ -0,0 +1,81 @@
+/** The environment key every implementor spawn — and its descendants — carries. */
+export declare const PROCESS_TREE_MARKER_ENV = "CODEVIBE_PROCESS_TREE_ID";
+export interface MarkedProcess {
+    pid: number;
+    /** Start time reported with the pid; the signal follows the scan immediately. */
+    startedAt: string;
+}
+export interface ReapResult {
+    killed: number;
+    /** Marked processes still present at the deadline (cleanup not proven). */
+    remaining: number;
+}
+/**
+ * A task-private working directory (canonical path) and the spawn's start: the
+ * reaper also takes this user's processes started no earlier than `notBeforeMs`
+ * (at the listing's one-second resolution) whose cwd is inside `workingDir`.
+ */
+export interface WorkingDirScope {
+    workingDir: string;
+    notBeforeMs: number;
+}
+export interface ReapOptions {
+    deadlineMs?: number;
+    workingDirScope?: WorkingDirScope;
+}
+export interface ReaperDeps {
+    platform?: NodeJS.Platform;
+    /** List this user's processes whose environment carries `token`. */
+    listMarked?: (token: string) => Promise<MarkedProcess[]>;
+    /** List this user's processes started in scope whose cwd is inside the working dir. */
+    listInWorkingDir?: (scope: WorkingDirScope) => Promise<MarkedProcess[]>;
+    signal?: (pid: number) => void;
+    sleep?: (ms: number) => Promise<void>;
+    selfPids?: ReadonlySet<number>;
+}
+/** The exact `KEY=value` token a descendant's environment carries. */
+export declare function processTreeMarkerToken(treeId: string): string;
+/**
+ * P46b ID-31 — what the POSIX process host sweeps when the desktop that owns it
+ * dies before its target (a crash): processes carrying `markerToken`, and — for a
+ * task-private working dir — processes started since the target whose cwd is
+ * inside `workingDir`. The same target set as `reapMarkedProcessTree`, run by the
+ * process that survives the desktop.
+ */
+export interface HostDescendantReap {
+    markerToken: string;
+    workingDir?: string;
+}
+/** The host descriptor for a spawn, or undefined when the spawn has no tree id. */
+export declare function hostDescendantReap(processTreeId: string | undefined, taskPrivateWorkingDir: string | undefined): HostDescendantReap | undefined;
+/** Exact-token match in a whitespace-separated command+environment line. */
+export declare function lineCarriesToken(line: string, token: string): boolean;
+/**
+ * macOS / BSD — `ps -E` appends each same-user process's environment to its
+ * command column. Columns: pid, uid, lstart (24 chars), command+environment.
+ */
+export declare function parsePsEnvironmentListing(output: string, token: string, uid: number): MarkedProcess[];
+/** `ps -o lstart` (C locale, local time) → epoch ms; NaN when unparseable. */
+export declare function parseLstart(lstart: string): number;
+/**
+ * This user's processes from a `pid uid lstart command` listing that started no
+ * earlier than `notBeforeMs`, compared at the listing's one-second resolution
+ * (a process started in the spawn's own second is included).
+ */
+export declare function processesStartedSince(output: string, uid: number, notBeforeMs: number): MarkedProcess[];
+/** `lsof -d cwd -Fn` output → pid → cwd. */
+export declare function parseLsofCwd(output: string): Map<number, string>;
+/**
+ * True when `candidate` is `dir` or a path inside it (no sibling-prefix match).
+ * Fails closed for a relative directory or the filesystem root, which no task
+ * owns.
+ */
+export declare function isInsideDir(candidate: string, dir: string): boolean;
+/**
+ * Reap every process carrying `treeId`'s marker — and, with a working-directory
+ * scope on macOS, every process started since the spawn inside that directory.
+ * Idempotent (a second call finds nothing). Never throws: a failed scan counts
+ * as "cleanup not proven" only when a target was seen and could not be
+ * confirmed gone.
+ */
+export declare function reapMarkedProcessTree(treeId: string, opts?: ReapOptions, deps?: ReaperDeps): Promise<ReapResult>;

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

@@ -5,7 +5,7 @@ import { type DeviceSigningKey } from './class-a-sign';
 import { EmitShellEventFn } from './hook-bridge';
 import { SubmitMergeGateVerdictInput } from './task-group-types';
 import { TrackRegistry } from './track-registry';
-import { AgentKind, AuthorityAction, ClassBInbound, GateDispatchPayload, HookEvent, ImplementorHandle, LocalExecutor, MergeGateDispatchPayload, ProbeHandle, ProcessRole, ReviewerDispatchPayload, ReviseFeedbackPayload, ReviewerHandle, SpawnArgs, TrackAssignedPayload, type DurableSessionResourceDisposeOptions, type WorkspaceDisposeOptions } from './types';
+import { AgentKind, AuthorityAction, ClassBInbound, GateDispatchPayload, HookEvent, ImplementorHandle, LocalExecutor, MergeGateDispatchPayload, ProbeHandle, ProcessRole, ReviewerDispatchPayload, ReviseFeedbackPayload, QueuedWorkEndedPayload, ReviewerHandle, SpawnArgs, TrackAssignedPayload, type DurableSessionResourceDisposeOptions, type WorkspaceDisposeOptions } from './types';
 import { type TeamExecution } from './team-execution-flag';
 import { type SnapshotBundlesView, type SnapshotMergeGateResult } from './snapshot-merge';
 import { type WorkspaceRootAuthority } from './workspace-authority';
@@ -113,6 +113,8 @@ export type SubstrateEngager = (input: {
      */
     requireConfined?: boolean;
     webBrowsingActive?: boolean;
+    /** F-P46a-4 — the spawn's process-tree id, folded into the sandbox environment. */
+    processTreeId?: string;
 }) => Promise<SubstrateEngageResult>;
 /** Backend lease is 15 minutes; three renewal opportunities fit inside it. */
 export declare const TEAM_TRACK_HEARTBEAT_INTERVAL_MS: number;
@@ -282,6 +284,8 @@ export interface LocalExecutorImplDeps {
     spawnReviewers?: (payload: ReviewerDispatchPayload) => Promise<void>;
     /** §3.C.23 — re-run the implementor for round N+1 on a REVISE_FEEDBACK packet. */
     runReviseRound?: (payload: ReviseFeedbackPayload) => Promise<void>;
+    /** P46b §3.6 — a never-started single task's slot ended (QUEUED_WORK_ENDED). */
+    queuedWorkEnded?: (payload: QueuedWorkEndedPayload) => Promise<void>;
     /**
      * CP-1.f execute-first (D5 / #PR-1 / #PR-3) — promote the task's SHADOW onto
      * the real tree on the `TaskAuthorized` Class-B edge. Wired straight through
@@ -349,6 +353,16 @@ export interface LocalExecutorImplDeps {
     } | undefined;
     /** P36 / R2-F2: Callback for aggregate team merge desktop audit summary. */
     onTeamMergeAuditSummary?: (summary: any) => void;
+    /**
+     * P46b §3.10 — a team's reviewed change could not be applied (paths changed
+     * since review, or failed to write) and the user tree was left unchanged.
+     * The shell opens the apply-conflict menu and the phone retry prompt.
+     */
+    onTeamApplyConflict?: (info: {
+        taskGroupId: string;
+        conflicts: readonly string[];
+        writeErrors: readonly string[];
+    }) => void;
     /**
      * Legacy-named TEST SEAM around the merge-gate body. Production defaults to
      * the reviewed-bundle filesystem snapshot implementation.

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

@@ -1,6 +1,7 @@
 import { spawn as nodeSpawn, type ChildProcess } from 'node:child_process';
 import { type ProcessIdentity } from './process-identity';
 import { type WorkspaceRootAuthority } from './workspace-authority';
+import type { HostDescendantReap } from './descendant-reaper';
 export type ProcessTreeOwnership = 'none' | 'posix-host' | 'posix-group' | 'windows-job';
 /**
  * Spawn through an original-handle POSIX host. The host owns the target's
@@ -15,6 +16,11 @@ export declare function spawnPosixOwnedProcess(command: string, args: readonly s
     workingDirAuthority?: WorkspaceRootAuthority;
     /** Additional exact directories authenticated at final target spawn. */
     launchPathAuthorities?: readonly WorkspaceRootAuthority[];
+    /**
+     * P46b ID-31 — the descendant sweep this host runs if the desktop dies
+     * before the target (the desktop's own reaper cannot run then).
+     */
+    descendantReap?: HostDescendantReap;
     /** @internal deterministic directory-durability failure seam. */
     syncOwnerDirectory?: (dir: string, file: string) => Promise<void>;
 }): ChildProcess;

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

@@ -91,6 +91,16 @@ export interface RunSnapshotMergeGateArgs {
     runGate?: (gateKind: VerificationGateKind, cwd: string, timeoutMs: number, signal?: AbortSignal, workingDirAuthority?: WorkspaceRootAuthority) => Promise<GateRunResult | null>;
     /** @internal swap/race seam immediately before a durable-journal filesystem proof. */
     beforeJournalFileRead?: (path: string) => Promise<void> | void;
+    /**
+     * P46b §3.10 — the reviewed team change could not be applied to the user tree
+     * (paths changed since review, or failed to write) and nothing was left
+     * applied. Paths are workspace-relative. Never called for an unresolved
+     * promote (its authority is retained for reconciliation).
+     */
+    onPromotionConflict?: (info: {
+        conflicts: readonly string[];
+        writeErrors: readonly string[];
+    }) => void;
 }
 /**
  * `UNRESOLVED` is deliberately not a wire-level MergeResult. It means durable

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

@@ -14,7 +14,7 @@ import { ImplementorHandle, ProbeHandle, ProcessRole, ReviewerHandle, SpawnArgs,
  * the role is always `'implementor'` for the substrate path, but taken as a
  * parameter so the marker value is explicit + testable.
  */
-export declare function buildSubstrateImplementorEnv(role: ProcessRole, sanitizedBase: Readonly<Record<string, string>>): Record<string, string>;
+export declare function buildSubstrateImplementorEnv(role: ProcessRole, sanitizedBase: Readonly<Record<string, string>>, processTreeId?: string): Record<string, string>;
 export declare function spawnImplementor(scope: AuthorityScope, args: SpawnArgs): Promise<ImplementorHandle>;
 /**
  * CP-7 §8 (Stage-1-resolved) — LOW-LEVEL legacy reviewer spawn primitive.

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

@@ -19,6 +19,8 @@ export interface SpawnArgs {
     signal?: AbortSignal;
     taskId?: string;
     webTurnActive?: boolean;
+    processTreeId?: string;
+    taskPrivateWorkingDir?: boolean;
     lifecycleAudit?: 'active_task' | 'none';
     onProcessSpawned?: ProcessSpawnedHook;
     onProcessExited?: ProcessExitedHook;
@@ -300,6 +302,16 @@ export interface ReviseFeedbackPayload {
     /** DETERMINISTIC dedup key keyed `(parentGateId, nextGateId, nextRound)` — the double-spawn guard. */
     reviseFeedbackId: string;
 }
+/**
+ * P46b §3.6 — `QUEUED_WORK_ENDED` Class B payload (engine → desktop). Sent once
+ * when the engine ends the slot of a single task that never started and halted
+ * it. Ids and a closed reason only. Pinned to
+ * `class_b_envelope.rs::QueuedWorkEndedPayload`.
+ */
+export interface QueuedWorkEndedPayload {
+    taskId: string;
+    reason: 'queued_task_expired' | 'tier_changed' | 'user_cancelled_queued_task';
+}
 export type ClassBInbound = {
     kind: 'PlannerDecisionApproved';
     signedEnvelope: SignedEnvelope;
@@ -340,6 +352,10 @@ export type ClassBInbound = {
     kind: 'ReviseFeedback';
     signedEnvelope: SignedEnvelope;
     payload: unknown;
+} | {
+    kind: 'QueuedWorkEnded';
+    signedEnvelope: SignedEnvelope;
+    payload: unknown;
 };
 export type ExecutorError = {
     kind: 'AuthorityRefusal';