@quantiya/codevibe-claude-plugin 2.0.101 → 2.0.103

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/engine-projection.d.ts

@@ -1,3 +1,4 @@
+import type { StoredFileClass } from '../local-executor/binary-classifier';
 import { type ShadowChangeKind } from '../local-executor/shadow-protocol';
 export declare const PROJECTION_BUDGET_BYTES: number;
 export declare const PROJECTION_INLINE_MAX_BYTES: number;
@@ -22,7 +23,14 @@ export interface ProjectionFile {
      * SHA-256 names, so a file listed by its identity line alone is never read or diffed.
      */
     readExcerpt(maxBytes: number): Promise<string>;
+    /**
+     * P63 Slice 3 (§8.6): a binary new version's class label. Such a file is sent as its identity line alone —
+     * `[codevibe-blob v1] <class>; <size> bytes; sha256 <hex>; review bundle: after/<path>` — and never read.
+     */
+    blobClass?: string;
 }
+/** The INDEX's class column and the blob identity line's `<class>` (§10.1). */
+export declare function classLabel(cls: StoredFileClass | undefined): string;
 export interface ProjectedFile {
     path: string;
     change_kind: ShadowChangeKind;
@@ -86,6 +94,7 @@ export declare function projectionFileFromCapture(file: {
         blob: string;
         size: number;
     };
+    file_class?: StoredFileClass;
 }, 
 /** The pre-task text when the real file still matches its recorded base hash; null otherwise (S2-5). */
 readBase: () => Promise<string | null>, 

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/media-approval.d.ts

@@ -0,0 +1,112 @@
+import type { ShadowDiffFile } from '../local-executor/shadow-protocol';
+import type { WithheldMediaChange } from '../local-executor/withheld-media';
+import type { OrchestrationAction, OrchestrationState } from './types';
+import type { WorkspaceOutcomeSink } from './workspace-terminal-coordinator';
+/** The pending kind: the media question for one subject (a task id, or `group:<taskGroupId>`). */
+export interface MediaApprovalState {
+    taskId: string;
+}
+/** At most this many files are named in the question; the rest are counted (S1R1-N5). */
+export declare const MEDIA_QUESTION_MAX_FILES = 5;
+/** "320 KB", "312 MB", "1.4 GB" (decimal units, as the phone and Finder show them). */
+export declare function humanBytes(bytes: number): string;
+/**
+ * The question asked before a reviewed change with media is applied, e.g. "Task #2 changes 2 media files: `intro.mp4`
+ * (video, 312 MB, 1:04), `clip.m4a` (audio, 320 KB, 0:45). Apply all changes? Reply yes to apply or no to keep your
+ * originals." Beyond `MEDIA_QUESTION_MAX_FILES` files the rest are counted with their total size. A team's question
+ * names the team ("Team #2 changes …"), matching its decline notice.
+ */
+export declare function mediaApprovalQuestion(taskLabel: string, files: ReadonlyArray<{
+    path: string;
+    change_kind: string;
+    label: string;
+    size: number | null;
+    duration: string | null;
+}>, subject?: 'Task' | 'Team'): string;
+/** The question for a list of withheld changes. */
+export declare function questionFor(label: string, withheld: readonly WithheldMediaChange[], subject?: 'Task' | 'Team'): string;
+/** What the gate needs from its loop. */
+export interface MediaApprovalHost {
+    /** The reviewed change (the durable record first, S1R1-N2). */
+    reviewed(taskId: string): Promise<readonly ShadowDiffFile[] | undefined>;
+    shadow(taskId: string): {
+        withheldMediaChanges(files: readonly ShadowDiffFile[]): Promise<WithheldMediaChange[]>;
+    } | undefined;
+    /** A team track: its bundle is published at once; the group asks before the merged result is applied. */
+    isTeamTrack(taskId: string): boolean;
+    label(taskId: string): string;
+    /** A team's label (its tracks' shared prefix, e.g. "#2" for "#2.1"), or a short id. */
+    groupLabel(taskGroupId: string): string;
+    promote(taskId: string): Promise<void>;
+    discard(taskId: string): Promise<void>;
+    halt(text: string): void;
+    /** The workspace-outcome record of a task authorized through a user decision (S1R1-F3); read at answer time. */
+    outcomeSink(): Pick<WorkspaceOutcomeSink, 'hasTaskResolution' | 'reserveTask' | 'completeTask'> | undefined;
+}
+export declare class MediaApprovalGate {
+    private readonly host;
+    private asker?;
+    private readonly phase;
+    private readonly onAnswer;
+    constructor(host: MediaApprovalHost);
+    /** Install the shell's question asker (it shows the question on the desktop and sends it to the phone, SF-7). */
+    setAsker(asker: ((subject: string, question: string) => void) | undefined): void;
+    /** The question for `subject` is open (asked and not yet answered). */
+    isAsked(subject: string): boolean;
+    /** Open a question; `false` when no surface can ask it (the caller fails closed). */
+    private open;
+    /**
+     * The TaskAuthorized promotion. A reviewed change with media is not applied until the user answers; nothing waits on
+     * the answer (it arrives as a reply). An interrupted apply replayed at start is not asked again: its apply had begun.
+     */
+    promoteOnTaskAuthorized(taskId: string): Promise<void>;
+    /** A notice about a team's media question, shown like the gate's own messages (desktop terminal and phone). */
+    notice(text: string): void;
+    /**
+     * A team group's question, asked once before its merged result is applied. Resolves `true` only on "yes"; `false` on
+     * any other answer, or at once when no surface can ask (the merge then applies nothing).
+     */
+    askForGroup(taskGroupId: string, label: string, withheld: readonly WithheldMediaChange[]): Promise<boolean>;
+    /** The local executor's team question: label it, and say so when the answer keeps the user's originals. */
+    askForTeam(taskGroupId: string, withheld: readonly WithheldMediaChange[]): Promise<boolean>;
+    /** The answer: yes applies the whole reviewed change; anything else applies nothing. A closed question does nothing. */
+    resolve(subject: string, approved: boolean): Promise<void>;
+}
+/** The gate of one loop, made on first use (the loop holds no field for it). */
+/** "#2.1" → "#2": a team is labelled by its tracks' shared prefix. */
+/** A team's label (`#N`) from the briefs of its member tasks; the group id's prefix when none is active. */
+export declare function groupLabelFor(briefs: ReadonlyMap<string, {
+    taskGroupId: string;
+}>, labelFor: (taskId: string) => string, taskGroupId: string): string;
+export declare function teamLabelFrom(trackLabel: string): string;
+export declare function mediaApprovalGateFor(owner: object, host: () => MediaApprovalHost): MediaApprovalGate;
+/** The shell store as the asker uses it. */
+export interface MediaQuestionStore {
+    getState(): Pick<OrchestrationState, 'pendingClarification'>;
+    dispatch(action: OrchestrationAction): void;
+    subscribe(listener: (state: OrchestrationState) => void): () => void;
+}
+/**
+ * S1R2-F1 — a mention turn (`@agent …`, `@all`) that arrives while the media question holds the pending slot is a fresh
+ * request, not an answer: the question is set aside BEFORE the turn's attachment ingest and routing (so the turn sees no
+ * pending, no seeded images), and is asked again only when the turn has finished (call the returned release in the
+ * turn's `finally`). Returns null when there is nothing to set aside.
+ */
+export declare function setMediaQuestionAside(store: MediaQuestionStore, text: string): (() => void) | null;
+/**
+ * Shows one media question at a time in the shell's pending slot. The question is raised outside any user turn, so the
+ * turn mirror never carries it to the phone (SF-7): `toPhone` sends it there each time it is shown — not while it
+ * waits behind another question, when a reply would answer that other question instead.
+ */
+export declare function installMediaApprovalAsker(gate: MediaApprovalGate | undefined, store: MediaQuestionStore, toPhone?: (text: string) => void): () => void;
+/**
+ * The shell side: the reply never reaches the planner; an affirmative reply applies, anything else applies nothing.
+ * The answer is taken (the subject leaves `asked`) BEFORE the pending slot is cleared, so the asker never mistakes an
+ * answered question for a lost one.
+ */
+export declare function handleMediaApprovalReply(args: {
+    gate: Pick<MediaApprovalGate, 'resolve'> | undefined;
+    taskId: string;
+    affirmative: boolean;
+    dispatch: (action: OrchestrationAction) => void;
+}): Promise<void>;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/quorum-loop.d.ts

@@ -7,6 +7,7 @@ import type { LocalExecutor } from '../local-executor';
 import type { ClassBInbound, QueuedWorkEndedPayload } from '../local-executor/types';
 import type { ImageAttachment } from './types';
 import { type TaskAuditSummaryModel, type ReviewHistorySnapshot, type UserDecisionRecord } from './audit-summary';
+import { type MediaApprovalGate } from './media-approval';
 import type { DecryptedReviewSummaryInput } from './gate-prompts';
 import type { ShellEventEmit, ShellEventEmitResult } from './emit-shell-event';
 import { type ImplementorMode } from '../local-executor/implementor-argv';
@@ -1645,6 +1646,8 @@ export declare class QuorumLoop {
     setTaskOrdinalSink(sink: TaskOrdinalSink | undefined): void;
     /** P46a C3 — install the desktop-local apply-conflict menu sink. */
     setApplyConflictSink(sink: ((menu: ApplyConflictMenu) => void) | undefined): void;
+    /** P63 Slice 3 §9.5 — this loop's media-approval gate (media-approval.ts): TaskAuthorized promotes through it. */
+    mediaApproval(): MediaApprovalGate;
     /** P46a C2 — install the retry-started notifier (the shell records the lifecycle row). */
     setRetryStartedSink(sink: ((info: {
         taskId: string;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/review-bundle.d.ts

@@ -1,6 +1,9 @@
 import { type BlobStore } from '../local-executor/blob-store';
+import type { StoredFileClass } from '../local-executor/binary-classifier';
 import type { BlobRef } from '../local-executor/change-manifest';
 import { type ShadowChangeKind } from '../local-executor/shadow-protocol';
+import { classLabel } from './engine-projection';
+export { classLabel };
 export interface ReviewBundleFile {
     path: string;
     change_kind: ShadowChangeKind;
@@ -28,6 +31,30 @@ export interface ReviewBundleFile {
         size: number | null;
         changed: boolean;
     };
+    /** Slice 3 (§10.1): the new version's class when it is not text (absent: text). */
+    afterClass?: StoredFileClass;
+    /** Slice 3 (§10.1): the user's version's class when it is not text (absent: text). */
+    beforeClass?: StoredFileClass;
+}
+/** How the bundle presented a change (§10.1): text diffed, Office extracted, a file to open, or withheld. */
+export type ReviewEntryKind = 'text' | 'office' | 'view' | 'withheld';
+export interface ReviewBundleEntry {
+    path: string;
+    change_kind: ShadowChangeKind;
+    kind: ReviewEntryKind;
+    /** Withheld (§8.1, §9.5): what the INDEX and the phone question say about it; its bytes are not in the bundle. */
+    withheld?: {
+        label: string;
+        size: number;
+        sha256: string;
+        container: string;
+        durationSeconds: number | null;
+    };
+    /** Office (§8.4): whether the extracted text changed, and the changed parts marked "no text change". */
+    office?: {
+        textChanged: boolean;
+        noTextParts: string[];
+    };
 }
 /** §5.7 / §7.4 — what the INDEX lists besides the changed files (R1-F6). */
 export interface ReviewIndexContext {
@@ -55,7 +82,20 @@ export interface ReviewBundleRecord {
         sha256: string;
         size: number;
     }>;
+    /** Slice 3: how each change was presented (receipts and the media question read this). */
+    entries?: ReviewBundleEntry[];
 }
+/**
+ * §8.2 (S2R1-F1) — the masked-original grant for a macOS reviewer: the original folder with a literal deny for every changed
+ * file whose bytes the bundle withholds, whatever its name. Fails closed to the bundle only (no original) when the record
+ * does not say how each change was presented or when the withheld files exceed the literal cap.
+ */
+export declare function maskedOriginalGrant(record: ReviewBundleRecord, dir: string): {
+    maskedOriginal: {
+        dir: string;
+        changedWithheld: readonly string[];
+    };
+} | Record<string, never>;
 /** Build the bundle. `bundleDir` must not exist; its parent must. Returns the hash record to re-check on return. */
 export declare function buildReviewBundle(input: {
     bundleDir: string;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/review-receipts.d.ts

@@ -19,10 +19,31 @@ export interface ReceiptFile {
     sha256: string;
     hasAfter: boolean;
     hasBefore: boolean;
+    /** Slice 3 (§8.4): how the bundle presented the change (absent: text). */
+    entryKind?: 'text' | 'office' | 'view' | 'withheld';
+    /** Office: whether the extracted text changed, and the changed parts marked "no text change". */
+    office?: {
+        textChanged: boolean;
+        noTextParts: readonly string[];
+    };
 }
+/** Slice 3 (§8.4): a receipt file's entry kind and Office facts, from the bundle record's entry for `filePath`. */
+export declare function receiptEntryFields(entries: ReadonlyArray<{
+    path: string;
+    kind: NonNullable<ReceiptFile['entryKind']>;
+    office?: {
+        textChanged: boolean;
+        noTextParts: string[];
+    };
+}> | undefined, filePath: string): Pick<ReceiptFile, 'entryKind' | 'office'>;
 export interface ReceiptRequest {
     id: string;
-    kind: 'line' | 'index';
+    /**
+     * line: a changed line, exact (whitespace-normalised); index: the INDEX row's SHA-256 prefix; parts (Slice 3, Office):
+     * every changed part marked "no text change", each named; describe (Slice 3, image/PDF): a one-line description,
+     * presence only — not machine-checkable (§8.4).
+     */
+    kind: 'line' | 'index' | 'parts' | 'describe';
     /** Bundle-relative file the request names (`after/<p>`, `before/<p>` or `INDEX.md`). */
     file: string;
     /** 1-based line number (kind `line`). */

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/types.d.ts

@@ -485,6 +485,9 @@ export interface TaskStartConfirmationState {
         singleFallbackBrief?: string;
     };
 }
+/** P63 Slice 3 §9.5 — the media question's pending kind (media-approval.ts). */
+import type { MediaApprovalState } from './media-approval';
+export type { MediaApprovalState };
 /**
  * P63 §6.4 — a START refused because its implementor cannot be confined on this machine. The question offers to run
  * it unconfined THIS ONCE; only an affirmative reply re-issues exactly these start arguments with `allowUnconfined`.
@@ -537,6 +540,8 @@ export interface PendingClarification {
     startConfirmation?: TaskStartConfirmationState;
     /** P63 §6.4 — its own pending kind beside `startConfirmation`: the "run it unconfined this once?" question. */
     confinementOptIn?: ConfinementOptInState;
+    /** P63 Slice 3 §9.5 — its own pending kind: apply a reviewed change that includes media files? */
+    mediaApproval?: MediaApprovalState;
 }
 /**
  * A1a #3/#4 — one numbered choice in a `PendingPlannerOffer`. Contract-ready
@@ -1047,6 +1052,7 @@ export type OrchestrationAction = {
     brainstorm?: BrainstormContextMetadata;
     startConfirmation?: TaskStartConfirmationState;
     confinementOptIn?: ConfinementOptInState;
+    mediaApproval?: MediaApprovalState;
 } | {
     type: 'EVENT_RECEIVED';
     event: EventStreamEntry;

package/node_modules/@quantiya/codevibe-core/dist/tool-activity/types.d.ts

@@ -71,11 +71,11 @@ export declare const ToolActivityGroupSchema: z.ZodObject<{
         id: string;
         ts: string;
     }[];
+    target?: string | undefined;
     detail?: {
         i: number;
         digest: string;
     }[] | undefined;
-    target?: string | undefined;
 }, {
     count: number;
     tool: string;
@@ -83,11 +83,11 @@ export declare const ToolActivityGroupSchema: z.ZodObject<{
         id: string;
         ts: string;
     }[];
+    target?: string | undefined;
     detail?: {
         i: number;
         digest: string;
     }[] | undefined;
-    target?: string | undefined;
 }>;
 export type ToolActivityGroup = z.infer<typeof ToolActivityGroupSchema>;
 /**
@@ -135,11 +135,11 @@ export declare const ToolActivityManifestSchema: z.ZodObject<{
             id: string;
             ts: string;
         }[];
+        target?: string | undefined;
         detail?: {
             i: number;
             digest: string;
         }[] | undefined;
-        target?: string | undefined;
     }, {
         count: number;
         tool: string;
@@ -147,11 +147,11 @@ export declare const ToolActivityManifestSchema: z.ZodObject<{
             id: string;
             ts: string;
         }[];
+        target?: string | undefined;
         detail?: {
             i: number;
             digest: string;
         }[] | undefined;
-        target?: string | undefined;
     }>, "many">;
     continues: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
@@ -162,11 +162,11 @@ export declare const ToolActivityManifestSchema: z.ZodObject<{
             id: string;
             ts: string;
         }[];
+        target?: string | undefined;
         detail?: {
             i: number;
             digest: string;
         }[] | undefined;
-        target?: string | undefined;
     }[];
     windowStart?: string | undefined;
     windowEnd?: string | undefined;
@@ -181,11 +181,11 @@ export declare const ToolActivityManifestSchema: z.ZodObject<{
             id: string;
             ts: string;
         }[];
+        target?: string | undefined;
         detail?: {
             i: number;
             digest: string;
         }[] | undefined;
-        target?: string | undefined;
     }[];
     windowStart?: string | undefined;
     windowEnd?: string | undefined;
@@ -254,11 +254,11 @@ export declare const ToolActivityOutboxEnvelopeSchema: z.ZodObject<{
                 id: string;
                 ts: string;
             }[];
+            target?: string | undefined;
             detail?: {
                 i: number;
                 digest: string;
             }[] | undefined;
-            target?: string | undefined;
         }, {
             count: number;
             tool: string;
@@ -266,11 +266,11 @@ export declare const ToolActivityOutboxEnvelopeSchema: z.ZodObject<{
                 id: string;
                 ts: string;
             }[];
+            target?: string | undefined;
             detail?: {
                 i: number;
                 digest: string;
             }[] | undefined;
-            target?: string | undefined;
         }>, "many">;
         continues: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
@@ -281,11 +281,11 @@ export declare const ToolActivityOutboxEnvelopeSchema: z.ZodObject<{
                 id: string;
                 ts: string;
             }[];
+            target?: string | undefined;
             detail?: {
                 i: number;
                 digest: string;
             }[] | undefined;
-            target?: string | undefined;
         }[];
         windowStart?: string | undefined;
         windowEnd?: string | undefined;
@@ -300,11 +300,11 @@ export declare const ToolActivityOutboxEnvelopeSchema: z.ZodObject<{
                 id: string;
                 ts: string;
             }[];
+            target?: string | undefined;
             detail?: {
                 i: number;
                 digest: string;
             }[] | undefined;
-            target?: string | undefined;
         }[];
         windowStart?: string | undefined;
         windowEnd?: string | undefined;
@@ -327,11 +327,11 @@ export declare const ToolActivityOutboxEnvelopeSchema: z.ZodObject<{
                 id: string;
                 ts: string;
             }[];
+            target?: string | undefined;
             detail?: {
                 i: number;
                 digest: string;
             }[] | undefined;
-            target?: string | undefined;
         }[];
         windowStart?: string | undefined;
         windowEnd?: string | undefined;
@@ -354,11 +354,11 @@ export declare const ToolActivityOutboxEnvelopeSchema: z.ZodObject<{
                 id: string;
                 ts: string;
             }[];
+            target?: string | undefined;
             detail?: {
                 i: number;
                 digest: string;
             }[] | undefined;
-            target?: string | undefined;
         }[];
         windowStart?: string | undefined;
         windowEnd?: string | undefined;

package/node_modules/@quantiya/codevibe-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.94",
+  "version": "2.0.95",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-claude-plugin",
-  "version": "2.0.101",
+  "version": "2.0.103",
   "description": "Control Claude Code from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "codevibe": {
@@ -48,7 +48,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "^2.0.94",
+    "@quantiya/codevibe-core": "^2.0.95",
     "@quantiya/quorum-core": "^1.0.1",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",