@aopslabs/aops 0.3.8 → 0.3.10

package/dist/commands/chatv3.js

@@ -3,9 +3,10 @@ import { Command } from 'commander';
 import { logSuccess } from '@aopslabs/xf-cli-ui';
 import { Chatv3Client, deriveKek, importEpochKey, MemoryKeyStore, parseInvite, unwrapEpochKey, } from '@aopslabs/domain-product-client-chatv3';
 import { resolveCliApiBaseUrl } from '../utils/api.js';
+import { planChatv3SendCursorAdvance } from '../utils/chatv3-cursor.js';
 import { applyCommonOptions, compactPayload, normalizeNonEmpty } from '../utils/command.js';
 import { buildOperatorCookbook } from '../utils/hosted-sugar.js';
-import { deleteChatv3Session, getChatv3SessionRecord, listChatv3SessionRecords, loadChatv3Session, resolveChatv3SessionStorePath, saveChatv3Session, summarizeChatv3Session, } from '../utils/chatv3-session-store.js';
+import { deleteChatv3Session, getChatv3SessionRecord, listChatv3SessionRecords, loadChatv3Session, resolveChatv3SessionStorePath, resolveChatv3SessionOwner, saveChatv3Session, summarizeChatv3Session, } from '../utils/chatv3-session-store.js';
 const AGENT_BOOTSTRAP_STEPS = [
     'Read channel and active-room rules before acting.',
     'Use chat for coordination and wake; use PM for task/review truth.',
@@ -58,15 +59,16 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export function guardChatv3UnknownSubcommand(argv) {
-    const index = argv.indexOf('chatv3');
+    const index = argv.findIndex((value) => value === 'chat' || value === 'chatv3');
     if (index < 0)
         return;
+    const commandName = argv[index];
     const top = argv[index + 1];
     if (!top || top.startsWith('-'))
         return;
     const nested = CHATV3_COMMAND_TREE[top];
     if (nested === undefined) {
-        throw new Error(`unknown chatv3 command '${top}'. Run aops-cli chatv3 --help.`);
+        throw new Error(`unknown ${commandName} command '${top}'. Run aops ${commandName} --help.`);
     }
     if (nested === null)
         return;
@@ -76,7 +78,7 @@ export function guardChatv3UnknownSubcommand(argv) {
     if (child === 'help')
         return;
     if (!nested.has(child)) {
-        throw new Error(`unknown chatv3 ${top} command '${child}'. Run aops-cli chatv3 ${top} --help.`);
+        throw new Error(`unknown ${commandName} ${top} command '${child}'. Run aops ${commandName} ${top} --help.`);
     }
 }
 function readTextInput(value, label) {
@@ -415,7 +417,8 @@ function summarizeChannelDeleteTarget(channel) {
 function buildEnvelope(params) {
     const resolvedContext = compactPayload({
         serverBaseUrl: params.serverBaseUrl,
-        storePath: resolveChatv3SessionStorePath(params.options.storePath),
+        storePath: resolveChatv3SessionStorePath(params.options.storePath, params.options.sessionOwner),
+        sessionOwner: resolveChatv3SessionOwner(params.options.sessionOwner),
     });
     if (params.options.json) {
         console.log(JSON.stringify(compactPayload({
@@ -494,11 +497,17 @@ async function persistRuntimeSnapshot(runtime, activeRoomId) {
         rooms: runtime.rooms.map(roomToSessionRoom),
         createdAt: runtime.record.createdAt,
     };
-    runtime.record = await saveChatv3Session(plain, runtime.secrets, { storePath: runtime.storePath });
+    runtime.record = await saveChatv3Session(plain, runtime.secrets, {
+        storePath: runtime.storePath,
+        owner: runtime.sessionOwner,
+    });
 }
 async function loadRuntime(options, sessionId) {
-    const storePath = resolveChatv3SessionStorePath(options.storePath);
-    const loaded = await loadChatv3Session(sessionId, { storePath });
+    const storePath = resolveChatv3SessionStorePath(options.storePath, options.sessionOwner);
+    const loaded = await loadChatv3Session(sessionId, {
+        storePath: options.storePath,
+        owner: options.sessionOwner,
+    });
     const serverBaseUrl = normalizeNonEmpty(options.apiBaseUrl) ?? loaded.record.serverBaseUrl;
     const keyStore = new MemoryKeyStore();
     if (loaded.secrets.wrapSecret) {
@@ -532,6 +541,7 @@ async function loadRuntime(options, sessionId) {
         channel,
         rooms,
         storePath,
+        sessionOwner: options.sessionOwner,
     };
     await hydrateStoredServerEpochKeys(runtime);
     if (channel.encryptionMode === 'server-encrypted') {
@@ -580,8 +590,8 @@ async function loadRuntimeForChannelGuard(options) {
     }
     if (!channelSelector)
         throw new Error('Provide --session <id> or --channel <channel-id-or-slug>.');
-    const storePath = resolveChatv3SessionStorePath(options.storePath);
-    const matches = (await listChatv3SessionRecords({ storePath }))
+    const storePath = resolveChatv3SessionStorePath(options.storePath, options.sessionOwner);
+    const matches = (await listChatv3SessionRecords({ storePath, owner: options.sessionOwner }))
         .filter((record) => channelMatchesSelector(record.channel, channelSelector));
     if (matches.length === 0)
         throw new Error(`No local ChatV3 session found for channel ${channelSelector}. Provide --session <id>.`);
@@ -656,10 +666,10 @@ export async function runChatv3ChannelCreate(options = {}) {
     const spaceSlug = resolveSpaceSlug(options.space);
     const mode = normalizeChannelMode(options.mode);
     const serverBaseUrl = resolveChatv3ServerBaseUrl(options);
-    const storePath = resolveChatv3SessionStorePath(options.storePath);
+    const storePath = resolveChatv3SessionStorePath(options.storePath, options.sessionOwner);
     const explicitSessionId = normalizeNonEmpty(options.session);
     if (options.saveSession && explicitSessionId && options.force !== true) {
-        const existing = await getChatv3SessionRecord(explicitSessionId, { storePath });
+        const existing = await getChatv3SessionRecord(explicitSessionId, { storePath, owner: options.sessionOwner });
         if (existing) {
             throw new Error(`Refusing to overwrite existing ChatV3 session "${explicitSessionId}" bound to channel ${existing.channel.slug} (${existing.channel.id}). Rerun with --force to replace it.`);
         }
@@ -683,7 +693,7 @@ export async function runChatv3ChannelCreate(options = {}) {
     let record = null;
     if (options.saveSession) {
         if (options.force !== true) {
-            const existing = await getChatv3SessionRecord(sessionId, { storePath });
+            const existing = await getChatv3SessionRecord(sessionId, { storePath, owner: options.sessionOwner });
             if (existing) {
                 throw new Error(`Refusing to overwrite ChatV3 session "${sessionId}" bound to channel ${existing.channel.slug} (${existing.channel.id}). Rerun with --force to replace it.`);
             }
@@ -712,7 +722,7 @@ export async function runChatv3ChannelCreate(options = {}) {
             memberToken,
             wrapSecret: parsedInvite.mode === 'server-encrypted' ? undefined : parsedInvite.wrapSecret,
             epochKeys,
-        }, { storePath });
+        }, { storePath, owner: options.sessionOwner });
         record = summarizeChatv3Session(saved);
     }
     const channelForGuidance = {
@@ -850,9 +860,9 @@ export async function runChatv3Join(invite, options = {}) {
         throw new Error('Provide --handle <agent-handle>.');
     const serverBaseUrl = normalizeNonEmpty(options.apiBaseUrl) ?? parsed.serverBaseUrl;
     const sessionId = sessionIdFor(handle, parsed.channelId, options.session);
-    const storePath = resolveChatv3SessionStorePath(options.storePath);
+    const storePath = resolveChatv3SessionStorePath(options.storePath, options.sessionOwner);
     if (options.saveSession && options.force !== true) {
-        const existing = await getChatv3SessionRecord(sessionId, { storePath });
+        const existing = await getChatv3SessionRecord(sessionId, { storePath, owner: options.sessionOwner });
         if (existing?.channel.id === parsed.channelId) {
             buildEnvelope({
                 options,
@@ -928,7 +938,7 @@ export async function runChatv3Join(invite, options = {}) {
             memberToken,
             wrapSecret: parsed.mode === 'server-encrypted' ? undefined : parsed.wrapSecret,
             epochKeys,
-        }, { storePath });
+        }, { storePath, owner: options.sessionOwner });
         record = summarizeChatv3Session(saved);
     }
     buildEnvelope({
@@ -960,12 +970,22 @@ export async function runChatv3Send(messageArg, options = {}) {
     const text = readTextInput(normalizeNonEmpty(options.text) ?? messageArg, '<message> or --text');
     const runtime = await loadRuntime(options, sessionId);
     const room = resolveRoom(runtime, options.room);
+    const receiptMatches = options.markDelivered || options.markRead
+        ? (await runtime.client.getReceipts(room.id).catch(() => [])).filter((receipt) => receipt.handle === runtime.record.handle)
+        : [];
+    const receiptBeforeSend = receiptMatches.length === 1 ? receiptMatches[0] : undefined;
     const sent = await runtime.client.sendText(room, text, normalizeNonEmpty(options.kind) ?? 'message');
+    const cursorAdvance = planChatv3SendCursorAdvance({
+        sentSeq: sent.seq,
+        snapshot: receiptBeforeSend,
+        markDelivered: options.markDelivered === true,
+        markRead: options.markRead === true,
+    });
     let delivered = null;
     let read = null;
-    if (options.markDelivered)
+    if (cursorAdvance.delivered.safe)
         delivered = await runtime.client.markDelivered(room.id, sent.seq);
-    if (options.markRead)
+    if (cursorAdvance.read.safe)
         read = await runtime.client.markRead(room.id, sent.seq);
     await persistRuntimeSnapshot(runtime, room.id);
     buildEnvelope({
@@ -985,6 +1005,7 @@ export async function runChatv3Send(messageArg, options = {}) {
             message: sent,
             delivered,
             read,
+            cursorAdvance,
             guidance: buildAgentGuidance({ channel: runtime.channel, rooms: runtime.rooms }),
         }),
     });
@@ -1412,7 +1433,10 @@ export async function runChatv3Leave(options = {}) {
     if (!self)
         throw new Error(`Active member for handle ${runtime.record.handle} not found.`);
     const member = await runtime.client.updateMember(self.id, { status: 'removed' });
-    const forgotten = options.keepSession === true ? false : await deleteChatv3Session(sessionId, { storePath: runtime.storePath });
+    const forgotten = options.keepSession === true ? false : await deleteChatv3Session(sessionId, {
+        storePath: runtime.storePath,
+        owner: runtime.sessionOwner,
+    });
     buildEnvelope({
         options,
         command: 'chatv3.leave',
@@ -1427,7 +1451,10 @@ export async function runChatv3Leave(options = {}) {
     });
 }
 export async function runChatv3SessionList(options = {}) {
-    const sessions = await listChatv3SessionRecords({ storePath: options.storePath });
+    const sessions = await listChatv3SessionRecords({
+        storePath: options.storePath,
+        owner: options.sessionOwner,
+    });
     buildEnvelope({
         options,
         command: 'chatv3.session.list',
@@ -1442,7 +1469,10 @@ export async function runChatv3SessionGet(options = {}) {
     const sessionId = normalizeNonEmpty(options.session);
     if (!sessionId)
         throw new Error('Provide --session <id>.');
-    const record = await getChatv3SessionRecord(sessionId, { storePath: options.storePath });
+    const record = await getChatv3SessionRecord(sessionId, {
+        storePath: options.storePath,
+        owner: options.sessionOwner,
+    });
     if (!record)
         throw new Error(`ChatV3 session not found: ${sessionId}`);
     buildEnvelope({
@@ -1470,7 +1500,10 @@ export async function runChatv3SessionForget(options = {}) {
     const sessionId = normalizeNonEmpty(options.session);
     if (!sessionId)
         throw new Error('Provide --session <id>.');
-    const deleted = await deleteChatv3Session(sessionId, { storePath: options.storePath });
+    const deleted = await deleteChatv3Session(sessionId, {
+        storePath: options.storePath,
+        owner: options.sessionOwner,
+    });
     buildEnvelope({
         options,
         command: 'chatv3.session.forget',
@@ -1480,11 +1513,13 @@ export async function runChatv3SessionForget(options = {}) {
     });
 }
 function applyChatv3Options(cmd) {
-    return applyCommonOptions(cmd.option('--store-path <path>', 'Session store path (default: AOPS_CHATV3_SESSION_STORE_PATH or ~/.aops/chatv3-sessions.json)'), { withAuth: false });
+    return applyCommonOptions(cmd
+        .option('--store-path <path>', 'Session store path override (default: agent-owned path under ~/.aops/chatv3/)')
+        .option('--session-owner <id>', 'Explicit local agent owner id (default: AOPS_CHATV3_SESSION_OWNER or detected agent session)'), { withAuth: false });
 }
-export function makeChatv3Command() {
-    const cmd = new Command('chatv3')
-        .description('ChatV3 encrypted product-channel CLI for agent sessions with bootstrap guidance; separate from hosted `aops-cli chat` coordination rooms');
+export function makeChatv3Command(commandName = 'chat') {
+    const cmd = new Command(commandName)
+        .description('ChatV3 encrypted channels, rooms, agent sessions, coordination, and foreground listening');
     applyChatv3Options(cmd.command('join')
         .argument('<invite>', 'chv3://join/... invite string')
         .requiredOption('--handle <handle>', 'Agent handle to join with')
@@ -1646,27 +1681,27 @@ export function makeChatv3Command() {
     });
     cmd.addHelpText('afterAll', buildOperatorCookbook({
         examples: [
-            'aops-cli chatv3 channel create --title "Round 2" --handle codex --space default --mode server-encrypted --save-session --json',
-            'aops-cli chatv3 channel delete --channel <id-or-slug> --confirm-slug <slug> --json',
-            'aops-cli chatv3 channel purge-before --before 2026-07-01T00:00:00.000Z --json',
-            'aops-cli chatv3 channel purge-before --before 2026-07-01T00:00:00.000Z --confirm --json',
-            'aops-cli chatv3 channels --space default --status active --json',
-            'aops-cli chatv3 join "<invite>" --handle codex --session codex --save-session --json',
-            'aops-cli chatv3 send --session codex --room general "Hazirim." --mark-delivered --mark-read --json',
-            'aops-cli chatv3 read --session codex --room general --after-seq 0 --mark-delivered --mark-read --json',
-            'aops-cli chatv3 listen --session codex --room general --after-seq 12 --timeout-sec 60 --json',
-            'aops-cli chatv3 binding add --session codex --room general --binding-type projectman.review-request --ref-id <rr-id> --title "Slice review" --json',
-            'aops-cli chatv3 binding list --session codex --room general --json',
-            'aops-cli chatv3 room brief --session codex --room general --for claude --json',
-            'aops-cli chatv3 room summary --session codex --room general --after-seq 40 --json',
-            'aops-cli chatv3 member list --session codex --json',
-            'aops-cli chatv3 member remove --session codex --channel <channel-id> --member <member-id> --json',
-            'aops-cli chatv3 presence set --session codex --room general --state working --note "reviewing RR" --json',
-            'aops-cli chatv3 leave --session codex --json',
-            'aops-cli chatv3 session list --json',
+            'aops chat channel create --title "Round 2" --handle codex --space default --mode server-encrypted --save-session --json',
+            'aops chat channel delete --channel <id-or-slug> --confirm-slug <slug> --json',
+            'aops chat channel purge-before --before 2026-07-01T00:00:00.000Z --json',
+            'aops chat channel purge-before --before 2026-07-01T00:00:00.000Z --confirm --json',
+            'aops chat channels --space default --status active --json',
+            'aops chat join "<invite>" --handle codex --session codex --save-session --json',
+            'aops chat send --session codex --room general "Hazirim." --mark-delivered --mark-read --json',
+            'aops chat read --session codex --room general --after-seq 0 --mark-delivered --mark-read --json',
+            'aops chat listen --session codex --room general --after-seq 12 --timeout-sec 60 --json',
+            'aops chat binding add --session codex --room general --binding-type projectman.review-request --ref-id <rr-id> --title "Slice review" --json',
+            'aops chat binding list --session codex --room general --json',
+            'aops chat room brief --session codex --room general --for claude --json',
+            'aops chat room summary --session codex --room general --after-seq 40 --json',
+            'aops chat member list --session codex --json',
+            'aops chat member remove --session codex --channel <channel-id> --member <member-id> --json',
+            'aops chat presence set --session codex --room general --state working --note "reviewing RR" --json',
+            'aops chat leave --session codex --json',
+            'aops chat session list --json',
         ],
         notes: [
-            '`aops-cli chatv3` talks to ChatV3 product channels/rooms. `aops-cli chat` remains the hosted AOPS coordination/wake room surface.',
+            '`aops chat` is the canonical ChatV3 channel/room surface; `aops chatv3` remains a compatibility alias.',
             'Join/send/read/session JSON includes result.guidance with channel/room rules plus agent bootstrap steps from the dedicated guidanceMarkdown field.',
             'listen exits 0 when messages are found and 22 on timeout. read/listen always include messages:[], messageCount, latestSeq, and caughtUp.',
             'binding add/list/remove stores loose channel/room refs only; room brief includes refs and cursors.',

package/dist/commands/doc.js

@@ -79,12 +79,12 @@ function resolveTextField(explicit, seed, key) {
     const seeded = seed[key];
     return typeof seeded === 'string' ? seeded : undefined;
 }
-function validatePageVersionStatus(value) {
+export function validatePageVersionStatus(value) {
     const normalized = normalizeNonEmpty(value)?.toLowerCase();
-    if (normalized === 'draft' || normalized === 'review' || normalized === 'published' || normalized === 'archived') {
+    if (normalized === 'draft' || normalized === 'published' || normalized === 'archived') {
         return normalized;
     }
-    throw new Error('Page version status must be draft, review, published, or archived.');
+    throw new Error('Page version status must be draft, published, or archived.');
 }
 function extractId(value) {
     return normalizeNonEmpty(value);
@@ -5144,7 +5144,7 @@ export function makeDocCommand() {
         .description('Update page-version metadata; content changes must use doc page draft-save')
         .option('--id <id>', 'Page version id')
         .option('--input <json>', 'JSON object or @file.json with update fields')
-        .option('--status <value>', 'Page version status: draft, review, published, archived')).action(async (options) => {
+        .option('--status <value>', 'Page version status: draft, published, archived')).action(async (options) => {
         await runDocPageVersionUpdate(options);
     }));
     const link = cmd.command('link').description('Docman structure linking commands');

package/dist/commands/pm/index.js

@@ -533,9 +533,7 @@ function addReviewRequestCommands(cmd) {
         .option('--requested-by <id>', 'Requesting agent/operator id')
         .option('--target-agent <id>', 'Target reviewer agent id')
         .option('--target-slot <slot>', 'Target reviewer role slot')
-        .option('--tag <value>', 'Repeatable review-request tag', collectRepeatedOption, [])
-        .option('--notify-room <room-id>', 'Best-effort: after the RR is created (--apply only), post a "REVIEW READY" wake into this hosted chat room. Requires --ping-from. Failure does not fail the command.')
-        .option('--ping-from <agent-id>', 'Agent id the --notify-room wake message is posted as (required when --notify-room is set)'), { destructive: false }).action(async (options) => {
+        .option('--tag <value>', 'Repeatable review-request tag', collectRepeatedOption, []), { destructive: false }).action(async (options) => {
         await runPmReviewRequestCreate(options);
     }));
     applyPmContextOptions(applyWriteOptions(rr
@@ -584,10 +582,9 @@ function addReviewRequestCommands(cmd) {
 function addHandoffCommands(cmd) {
     applyPmContextOptions(cmd
         .command('resume')
-        .description('Composed paste-ready resume brief: active sprint windows, review queue for an agent, open issues/feedback, durable memory, optional hosted chat unread')
+        .description('Composed paste-ready resume brief: active sprint windows, review queue for an agent, open issues/feedback, and durable memory')
         .requiredOption('--for <agent-id>', 'Agent the brief is for')
         .option('--limit <count>', 'Max rows per section', (value) => Number.parseInt(String(value), 10))
-        .option('--with-chat', 'Include hosted chat unread summary (single hosted call; degrades gracefully when the server is unavailable)')
         .action(async (options) => {
         await runPmResumeBrief(options);
     }));

package/dist/commands/pm/projectman.js

@@ -5537,11 +5537,6 @@ export async function runPmReviewRequestCreate(options = {}) {
         const title = normalizeNonEmpty(options.title);
         if (!title)
             throw new Error('Missing required --title.');
-        const notifyRoom = normalizeNonEmpty(options.notifyRoom);
-        const pingFrom = normalizeNonEmpty(options.pingFrom);
-        if (notifyRoom && !pingFrom) {
-            throw new Error('--notify-room requires --ping-from <agent-id> (the agent the wake message is posted as).');
-        }
         const execution = await prepareExecution(options);
         if (!execution)
             return;
@@ -5616,57 +5611,12 @@ export async function runPmReviewRequestCreate(options = {}) {
             toolId: 'projectman.review-request.create',
             input,
         });
-        let reviewPing;
-        if (notifyRoom) {
-            const created = unwrapResultData(unwrapHostedToolResult(payload)) ?? {};
-            const rrId = normalizeNonEmpty(created.id) ?? normalizeNonEmpty(created.localId);
-            const rrTitle = normalizeNonEmpty(created.title) ?? title;
-            const rrScope = normalizeNonEmpty(created.reviewScope) ?? normalizeNonEmpty(options.reviewScope) ?? '—';
-            const scopeId = resolveOwnerScopeIdFromBinding(execution.resolvedContext);
-            const wakeText = `REVIEW READY — RR ${rrId ?? '(unknown)'}: ${rrTitle}. Scope: ${rrScope}. ` +
-                `Read: aops-cli pm review-request get --id ${rrId ?? '<rr-id>'} --json`;
-            try {
-                const apiState = await requireApiState(options);
-                if (!apiState) {
-                    reviewPing = { roomId: notifyRoom, status: 'failed', error: 'No API state (authenticate / configure host first).' };
-                }
-                else if (!scopeId) {
-                    reviewPing = { roomId: notifyRoom, status: 'failed', error: 'No scopeId resolved for the chat message; bind project context or pass --project-id.' };
-                }
-                else {
-                    const pingPayload = await invokeHostedToolWithApiState(apiState, {
-                        ...execution.gatewayOptions,
-                        toolId: 'agentspace.chat-message.send',
-                        input: {
-                            data: compactPayload({
-                                scopeId,
-                                roomId: notifyRoom,
-                                authorAgentId: pingFrom,
-                                text: wakeText,
-                            }),
-                        },
-                        apply: true,
-                    });
-                    const sent = unwrapResultData(unwrapHostedToolResult(pingPayload)) ?? {};
-                    const messageSeq = typeof sent.seq === 'number' ? sent.seq : undefined;
-                    reviewPing = compactPayload({ roomId: notifyRoom, status: 'sent', messageSeq });
-                }
-            }
-            catch (error) {
-                const pingMessage = error instanceof Error ? error.message : String(error);
-                reviewPing = { roomId: notifyRoom, status: 'failed', error: pingMessage };
-            }
-            if (reviewPing.status === 'failed') {
-                logWarn(`Review ping to room ${notifyRoom} failed (RR was still created): ${String(reviewPing.error)}`);
-            }
-        }
         emitCommandResult(options, {
             command: 'pm.review-request.create',
             toolId: 'projectman.review-request.create',
             resolvedContext: buildResolvedContextEnvelope(execution.resolvedContext),
             input,
             payload,
-            sideEffects: reviewPing ? { reviewPing } : undefined,
         });
     }
     catch (error) {
@@ -5842,40 +5792,6 @@ export async function runPmResumeBrief(options = {}) {
             summary: briefLine(entry.content),
             nextAction: normalizeNonEmpty(entry.nextAction),
         }));
-        let chat;
-        if (options.withChat === true) {
-            try {
-                const apiState = await requireApiState(options);
-                if (apiState) {
-                    const payload = await invokeHostedToolWithApiState(apiState, {
-                        ...execution.gatewayOptions,
-                        toolId: 'agentspace.chat.catchup',
-                        input: { data: { agentId } },
-                    });
-                    const result = unwrapHostedToolResult(payload);
-                    const data = unwrapResultData(result);
-                    const rooms = Array.isArray(data?.rooms) ? data.rooms : [];
-                    chat = compactPayload({
-                        unreadCount: data?.unreadCount ?? 0,
-                        rooms: rooms
-                            .filter((entry) => Number(entry.unreadCount ?? 0) > 0)
-                            .map((entry) => {
-                            const room = isRecord(entry.room) ? entry.room : {};
-                            return compactPayload({
-                                roomId: room.id,
-                                slug: room.slug,
-                                title: room.title,
-                                unreadCount: entry.unreadCount,
-                            });
-                        }),
-                        hint: `aops-cli chat catchup --for ${agentId} --peek --summary --json`,
-                    });
-                }
-            }
-            catch (error) {
-                chat = { status: 'unavailable', message: briefLine(error instanceof Error ? error.message : String(error), 200) };
-            }
-        }
         const markdownLines = [
             `# AOPS Resume Brief — ${resolvedContext.projectName ?? resolvedContext.projectId ?? 'project'} (for ${agentId})`,
             '',
@@ -5903,19 +5819,13 @@ export async function runPmResumeBrief(options = {}) {
             ...(durableMemories.length > 0
                 ? durableMemories.map((entry) => `- [${String(entry.createdAt ?? '').slice(0, 10)}] ${entry.summary}${entry.nextAction ? ` — next: ${briefLine(entry.nextAction, 100)}` : ''}`)
                 : ['- (none)']),
-            ...(chat
-                ? ['', `## Hosted chat unread${chat.status === 'unavailable' ? ' (unavailable)' : ` (${chat.unreadCount ?? 0})`}`,
-                    ...(Array.isArray(chat.rooms) && chat.rooms.length > 0
-                        ? chat.rooms.map((room) => `- ${room.slug ?? room.roomId}: ${room.unreadCount} unread`)
-                        : [chat.status === 'unavailable' ? `- ${chat.message}` : '- (none)'])]
-                : []),
             '',
             '## Resume prompt',
             '```text',
             `You are ${agentId}, resuming work on project ${resolvedContext.projectName ?? resolvedContext.projectId ?? ''} (repo ${resolvedContext.repoRoot}).`,
             `1. Review queue first: aops-cli pm review-request list --target-agent ${agentId} --json`,
             `2. Memory: aops-cli mem resume --subject project --json`,
-            `3. Chat: aops-cli chat catchup --for ${agentId} --peek --summary --json`,
+            `3. Chat: aops chat session list --json, then read/listen with ${agentId}'s own ChatV3 session`,
             '```',
         ];
         const markdown = markdownLines.join('\n');
@@ -5939,7 +5849,6 @@ export async function runPmResumeBrief(options = {}) {
                 id: entry.localId ?? entry.id, severity: entry.severity, title: entry.title,
             })),
             durableMemories,
-            chat,
             markdown,
         });
         if (options.json) {
@@ -5947,7 +5856,7 @@ export async function runPmResumeBrief(options = {}) {
                 command: 'pm.resume-brief',
                 toolId: 'projectman.resume-brief',
                 resolvedContext: buildResolvedContextEnvelope(resolvedContext),
-                input: compactPayload({ for: agentId, limit, withChat: options.withChat || undefined }),
+                input: compactPayload({ for: agentId, limit }),
                 payload: { ok: true, data: brief },
             });
             return;
@@ -5978,15 +5887,29 @@ export async function runPmReviewRequestResult(options = {}) {
         const execution = await prepareExecution(options, { requireProject: true });
         if (!execution)
             return;
+        const resolvedId = isUuidLike(id)
+            ? id
+            : await resolveReviewRequestId(execution, options, id);
+        const resultReferences = normalizeArrayValues(options.reference) ?? [];
+        if (outcome.toLowerCase() === 'approved') {
+            const requestPayload = await invokeProjectmanReadTool(execution, options, {
+                toolId: 'projectman.review-request.get',
+                input: { id: resolvedId },
+            });
+            const request = unwrapResultData(unwrapHostedToolResult(requestPayload));
+            if (!request)
+                throw new Error(`Review request "${resolvedId}" was not found.`);
+            assertApprovedReviewEvidenceReferences(outcome, Array.isArray(request.references) ? request.references : [], resultReferences);
+        }
         const input = compactPayload({
-            id,
+            id: resolvedId,
             reviewer,
             outcome,
             summary,
             positives: normalizeArrayValues(options.positive),
             concerns: normalizeArrayValues(options.concern),
             objections: normalizeArrayValues(options.objection),
-            references: normalizeArrayValues(options.reference),
+            references: resultReferences,
             issueIds: normalizeArrayValues(options.issue),
             basedOnSeqRange: parseJsonObjectOption(options.basedOnSeqRange, '--based-on-seq-range'),
             idempotencyKey: normalizeNonEmpty(options.idempotencyKey),
@@ -6029,6 +5952,24 @@ export async function runPmReviewRequestResult(options = {}) {
         process.exitCode = 1;
     }
 }
+const IMMUTABLE_SHA256_REFERENCE = /sha256:[a-f0-9]{64}/i;
+export function assertApprovedReviewEvidenceReferences(outcome, requestReferences, resultReferences) {
+    if (outcome.trim().toLowerCase() !== 'approved')
+        return;
+    const required = requestReferences
+        .filter((value) => typeof value === 'string')
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0 && IMMUTABLE_SHA256_REFERENCE.test(value));
+    if (required.length === 0)
+        return;
+    const recorded = new Set(resultReferences
+        .filter((value) => typeof value === 'string')
+        .map((value) => value.trim()));
+    const missing = [...new Set(required)].filter((reference) => !recorded.has(reference));
+    if (missing.length > 0) {
+        throw new Error(`Approved review results must repeat every immutable SHA-256 evidence reference from the request exactly. Missing: ${missing.join(', ')}`);
+    }
+}
 export async function runPmReviewRequestDelete(options = {}) {
     try {
         ensureWriteFlags('delete', options);

package/dist/lib/agent-assets/native-fs.js

@@ -543,9 +543,9 @@ function defaultNativeRoot() {
     return moduleDirectory.endsWith(`${path.sep}dist`) ? bundled : compiledOrSource;
 }
 function injectedNativeManifestSha256() {
-    return typeof __AOPS_AGENT_ASSETS_NATIVE_MANIFEST_SHA256__ === 'undefined'
+    return typeof "b97413fd3d4d2568a5a37483a7bcea62ceb48cadbbb76dbabb9109e7cf1ca161" === 'undefined'
         ? undefined
-        : __AOPS_AGENT_ASSETS_NATIVE_MANIFEST_SHA256__;
+        : "b97413fd3d4d2568a5a37483a7bcea62ceb48cadbbb76dbabb9109e7cf1ca161";
 }
 function sha256(bytes) {
     return createHash('sha256').update(bytes).digest('hex');

package/dist/lib/agent-assets/release-input.js

@@ -184,6 +184,12 @@ export async function verifyAndLoadCommunityCoreReleaseInput(options) {
     return loadVerifiedCommunityCoreReleaseInput(bundle);
 }
 export async function verifyAndLoadCommunityCatalogReleaseInputs(options) {
+    return (await verifyAndLoadCommunityCatalogRelease(options)).packages;
+}
+export async function verifyAndLoadCommunityCatalogRelease(options) {
     const bundle = await verifyCommunityRelease(options);
-    return loadVerifiedCommunityCatalogReleaseInputs(bundle);
+    return Object.freeze({
+        releaseSetSha256: bundle.agentAssets.setSha256,
+        packages: loadVerifiedCommunityCatalogReleaseInputs(bundle),
+    });
 }

package/dist/lib/setup-official-catalog-bridge.js

@@ -1,7 +1,7 @@
 import { lstatSync, realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
-import { verifyAndLoadCommunityCatalogReleaseInputs } from './agent-assets/release-input.js';
+import { verifyAndLoadCommunityCatalogRelease } from './agent-assets/release-input.js';
 import { inspectCommunityInstall } from './community-lifecycle.js';
 import { inspectCommunityNativeInstall } from './community-native-lifecycle.js';
 import { resolveCommunityRepo } from './community-repo-discovery.js';
@@ -101,18 +101,28 @@ export async function resolveSetupOfficialCatalogReleaseV1(options = {}, depende
     throw new Error('setup_init_catalog_verified_release_unavailable:reinstall_the_official_aops_cli_or_run_from_a_signed_community_release_or_use_--catalog-release_<path>_or_--no-catalog');
 }
 export function createSetupOfficialCatalogProviderV1(dependencies = {}) {
-    const loadRelease = dependencies.loadRelease ?? verifyAndLoadCommunityCatalogReleaseInputs;
+    const loadRelease = dependencies.loadRelease ?? verifyAndLoadCommunityCatalogRelease;
     const createAdapter = dependencies.createAdapter ?? createHostedOfficialCatalogAdapterV1;
     return Object.freeze({
         async resolveRelease(options) {
             return resolveSetupOfficialCatalogReleaseV1(options, dependencies);
         },
         async reconcile(options) {
-            const inputs = await loadRelease({
+            const release = await loadRelease({
                 releaseRoot: options.fromRelease,
                 verificationMode: 'offline',
             });
-            const packages = buildOfficialCatalogPackageImports(inputs);
+            const packages = buildOfficialCatalogPackageImports(release.packages);
+            if (packages.length === 0) {
+                return Object.freeze({
+                    state: 'current',
+                    scopeSlug: OFFICIAL_CATALOG_SCOPE_V1.slug,
+                    releaseSetSha256: release.releaseSetSha256,
+                    mutation: 'not-required',
+                    historyDeleteCount: 0,
+                    activationEffects: OFFICIAL_CATALOG_NO_ACTIVATION_EFFECTS_V1,
+                });
+            }
             const adapter = await createAdapter({
                 apiBaseUrl: options.apiBaseUrl,
                 timeoutMs: options.timeoutMs,

package/dist/main.js

@@ -20,7 +20,6 @@ import { makeMemoryCommand } from './commands/memory.js';
 import { makeCheckpointCommand } from './commands/checkpoint.js';
 import { makeExperienceCommand } from './commands/experience.js';
 import { makeDiscussCommand } from './commands/discuss.js';
-import { makeChatCommand } from './commands/chat.js';
 import { guardChatv3UnknownSubcommand, makeChatv3Command } from './commands/chatv3.js';
 import { makeAgentProfileCommand } from './commands/agent-profile.js';
 import { makePromptCommand } from './commands/prompt.js';
@@ -134,8 +133,8 @@ export function buildCommunityProgram() {
     program.addCommand(makeCheckpointCommand());
     program.addCommand(makeExperienceCommand());
     program.addCommand(makeDiscussCommand());
-    program.addCommand(makeChatCommand());
-    program.addCommand(makeChatv3Command());
+    program.addCommand(makeChatv3Command('chat'));
+    program.addCommand(makeChatv3Command('chatv3'));
     program.addCommand(makeAgentProfileCommand());
     program.addCommand(makePromptCommand());
     program.addCommand(makeProjectCommand());

package/dist/seeds/agents-md.js

@@ -44,7 +44,7 @@ export const AOPS_AGENTS_MD_TEMPLATE_SEEDS = [
             'Run a standalone discuss topic for material design decisions; give every peer enough independent context to research and form its own stance.',
             'Drive at least four substantive non-final turns, then each agent files a kind=final-stance turn before concluding.',
             'Confirm completeness from JSON (lifecycleState / missingTurnFinalStances), then conclude and finalize the outputs with no _TBD_ placeholders.',
-            'Surface decisions explicitly: there is no auto bridge — carry the discussion-topic ref into a PM review-request/issue and ping the hosted chat room.',
+            'Surface decisions explicitly: there is no auto bridge — carry the discussion-topic ref into a PM review-request/issue and ping the ChatV3 room with the current agent-owned session.',
             'Coordination/wake lives in aops-cli-chat; review + execution truth lives in aops-cli-projectman.',
             'Conclude only after final stances are recorded; session/board closeout stays operator-only.',
         ],