@raidiant/notifai 0.2.0 → 0.2.1

package/dist/commands.d.ts

@@ -209,7 +209,7 @@ export declare function configSetCommand(deps: CommandDeps, key: string, rawValu
  * 1.5.x, `owner/repo@name` selects a skill; a Git ref belongs after `#`.
  * Keep this immutable and public because the command is printed to users.
  */
-export declare const SKILLS_SOURCE = "Raidiant-io/notifai#v0.2.0";
+export declare const SKILLS_SOURCE = "Raidiant-io/notifai#v0.2.1";
 /** Derive a contract-valid project slug from a directory name. */
 export declare function projectSlugFrom(name: string): string;
 export interface InitFlags {

package/dist/commands.js

@@ -433,20 +433,25 @@ export async function repliesCommand(deps, requestedId, flags) {
         deps.io.err('Pass a request id or --pending, not both.');
         return EXIT.usage;
     }
-    let requestId = requestedId;
+    let requestIds = requestedId === undefined ? [] : [requestedId];
     if (flags.pending === true) {
         const sessionId = readProjectSession(deps.cwd, deps.env, (deps.now ?? Date.now)());
         if (sessionId === null) {
             deps.io.err('No active session pointer is available in this directory.');
             return EXIT.noReply;
         }
-        requestId = readSessionState(sessionId, deps.env).pending?.request_id;
-        if (requestId === undefined) {
+        // Every delivered question in the session's queue, in registration order —
+        // an agent may have several outstanding at once.
+        const state = readSessionState(sessionId, deps.env);
+        requestIds = (Array.isArray(state.pending) ? state.pending : [])
+            .map((entry) => entry.request_id)
+            .filter((id) => id !== undefined);
+        if (requestIds.length === 0) {
             deps.io.err(`Session ${sessionId} has no pushed question pending.`);
             return EXIT.noReply;
         }
     }
-    if (requestId === undefined) {
+    if (requestIds.length === 0) {
         deps.io.err('Pass a request id or --pending.');
         return EXIT.usage;
     }
@@ -455,27 +460,44 @@ export async function repliesCommand(deps, requestedId, flags) {
     if (!authed)
         return EXIT.auth;
     try {
-        const result = await waitForReply(authed.client, requestId, {
-            timeoutSeconds: waitSeconds,
-            afterSeq,
-            now: deps.now,
-            sleep: deps.sleep,
-        });
-        if (flags.json) {
-            deps.io.out(JSON.stringify({ ...result.response, degraded: result.degraded }, null, 2));
+        let anyReplies = false;
+        let anyDegraded = false;
+        let allTimedOut = true;
+        const jsonBodies = [];
+        for (const requestId of requestIds) {
+            const result = await waitForReply(authed.client, requestId, {
+                timeoutSeconds: waitSeconds,
+                afterSeq,
+                now: deps.now,
+                sleep: deps.sleep,
+            });
+            if (flags.json) {
+                jsonBodies.push({ ...result.response, degraded: result.degraded });
+            }
+            else if (result.response.replies.length > 0) {
+                if (flags.pending === true)
+                    deps.io.out(`pending request ${requestId}`);
+                printReplies(deps, result.response.replies);
+            }
+            else {
+                printNoReply(deps, requestId, result.response.reply_expires_at);
+            }
+            anyReplies ||= result.response.replies.length > 0;
+            anyDegraded ||= result.degraded;
+            allTimedOut &&= result.timedOut;
         }
-        else if (result.response.replies.length > 0) {
-            if (flags.pending === true)
-                deps.io.out(`pending request ${requestId}`);
-            printReplies(deps, result.response.replies);
+        if (flags.json) {
+            // One request keeps the response shape agents already parse; several
+            // (only possible via --pending) arrive as an array in queue order.
+            deps.io.out(JSON.stringify(jsonBodies.length === 1 ? jsonBodies[0] : jsonBodies, null, 2));
         }
-        else
-            printNoReply(deps, requestId, result.response.reply_expires_at);
-        if (result.degraded) {
+        if (anyDegraded) {
             deps.io.err(DEGRADED_WAIT_WARNING);
             return EXIT.network;
         }
-        return result.timedOut ? EXIT.noReply : EXIT.ok;
+        if (anyReplies)
+            return EXIT.ok;
+        return allTimedOut ? EXIT.noReply : EXIT.ok;
     }
     catch (err) {
         return reportError(deps, err);
@@ -1462,7 +1484,7 @@ export async function configSetCommand(deps, key, rawValue, flags) {
  * 1.5.x, `owner/repo@name` selects a skill; a Git ref belongs after `#`.
  * Keep this immutable and public because the command is printed to users.
  */
-export const SKILLS_SOURCE = 'Raidiant-io/notifai#v0.2.0';
+export const SKILLS_SOURCE = 'Raidiant-io/notifai#v0.2.1';
 function skillSourceParts() {
     const match = /^([^#]+)#(.+)$/.exec(SKILLS_SOURCE);
     return match === null ? null : { source: match[1], ref: match[2] };
@@ -2474,12 +2496,16 @@ function remedyLine(state) {
  * way and is not worth re-deriving. The judgment added here is which failures
  * actually stand in the way.
  *
- * Two do not. A hook that has never fired is the normal condition of an
- * install thirty seconds old, and OpenCode's inability to resume an idle turn
- * is a property of that harness rather than a fault in this setup. Treating
- * either as blocking would mean `init` could never finish for an OpenCode
- * user, or could only finish after a session had already run — so both report
- * as things worth knowing rather than things to fix.
+ * Not everything failed is in the way. A pointer that has never been
+ * published is the normal condition of an install thirty seconds old — the
+ * next prompt fixes it and no command can — and OpenCode's inability to
+ * resume an idle turn is a property of that harness rather than a fault in
+ * this setup. Treating those as blocking would mean `init` could never
+ * finish for an OpenCode user, or could only finish after a session had
+ * already run — so they report as things worth knowing rather than things to
+ * fix, and `init` walks on to the states it can actually close, delivery
+ * proof included. Which failures are informational, and what the true remedy
+ * is, is each check's own call (`HookCheck`).
  */
 function hookStates(deps) {
     const installations = findInstallations(deps.cwd, deps.env);
@@ -2519,23 +2545,30 @@ function hookStates(deps) {
     }
     /** Real but not in the way; see the note above. */
     const informational = new Set(['hooks (opencode continuation)']);
-    if (active === null)
-        informational.add('hooks (fired)');
     return [
         ...hookChecks(deps).map((check) => ({
             id: check.name.replace(/[ ()]+/g, '-').replace(/-$/, ''),
             title: check.name === 'hooks' || check.name.startsWith('hooks (active')
                 ? 'Question routing'
                 : check.name,
-            status: check.ok ? 'ready' : informational.has(check.name) ? 'optional-gap' : 'gap',
+            status: check.ok
+                ? 'ready'
+                : check.informational === true || informational.has(check.name)
+                    ? 'optional-gap'
+                    : 'gap',
             detail: check.detail,
             ...(check.ok
                 ? {}
                 : {
                     remedy: {
                         by: 'user-here',
-                        summary: 'the detail above names what to change',
-                        command: 'notifai hooks install',
+                        // The check's own remedy when it has one; the generic reinstall
+                        // line was wrong exactly where it mattered (an unfired pointer
+                        // needs a prompt, not `hooks install`).
+                        ...(check.remedy ?? {
+                            summary: 'the detail above names what to change',
+                            command: 'notifai hooks install',
+                        }),
                     },
                 }),
         })),
@@ -2573,21 +2606,52 @@ function hookChecks(deps) {
             detail: activeInstallations.length > 0
                 ? `active ${active.label} session has a matching hook installation`
                 : `active ${active.label} session has no matching hook installation — run \`notifai hooks install --harness ${active.harness}\``,
+            ...(activeInstallations.length > 0
+                ? {}
+                : {
+                    remedy: {
+                        summary: `install hooks for the active ${active.label} session`,
+                        command: `notifai hooks install --harness ${active.harness}`,
+                    },
+                }),
         });
         if (activeInstallations.length > 0) {
             const pointer = readProjectSessionPointer(deps.cwd, deps.env, (deps.now ?? Date.now)());
-            const matches = pointer !== null &&
-                pointer.harness === active.harness &&
-                (active.sessionId === undefined || pointer.sessionId === active.sessionId);
-            checks.push({
-                name: 'hooks (active session)',
-                ok: matches,
-                detail: pointer === null
-                    ? `active ${active.label} session has not published a live pointer — send one ${active.label} prompt, then check again`
-                    : matches
+            if (pointer === null) {
+                // The normal condition of hooks installed moments ago: the pointer
+                // appears when the harness next fires a hook, and no command can
+                // force that. Informational, so `init` walks on to the states it can
+                // actually prove instead of exiting over evidence only time produces.
+                checks.push({
+                    name: 'hooks (active session)',
+                    ok: false,
+                    informational: true,
+                    detail: `active ${active.label} session has not published a live pointer — send one ${active.label} prompt, then check again`,
+                    remedy: {
+                        summary: `send one ${active.label} prompt — its hook publishes the routing pointer`,
+                        command: 'notifai doctor',
+                    },
+                });
+            }
+            else {
+                const matches = pointer.harness === active.harness &&
+                    (active.sessionId === undefined || pointer.sessionId === active.sessionId);
+                checks.push({
+                    name: 'hooks (active session)',
+                    ok: matches,
+                    detail: matches
                         ? `the project pointer belongs to the active ${active.label} session`
                         : `the project pointer belongs to another ${active.label} session or harness; refusing cross-session routing`,
-            });
+                    ...(matches
+                        ? {}
+                        : {
+                            remedy: {
+                                summary: `send one ${active.label} prompt in this session so the pointer belongs to it`,
+                                command: 'notifai doctor',
+                            },
+                        }),
+                });
+            }
         }
     }
     // A handler naming an event this build dropped exits 2 every time the harness
@@ -2655,9 +2719,20 @@ function hookChecks(deps) {
     checks.push({
         name: 'hooks (fired)',
         ok: fired,
+        // Never-fired is evidence about the past, not a fault in the setup, and
+        // the cure is a prompt no command can send.
+        informational: true,
         detail: fired
             ? 'a session in this directory has run them'
             : `no session pointer from the last 24 hours — ${hookActivationAdvice(activationInstallations)}`,
+        ...(fired
+            ? {}
+            : {
+                remedy: {
+                    summary: 'send one prompt in a session here, then re-check',
+                    command: 'notifai doctor',
+                },
+            }),
     });
     if (installations.some((installation) => installation.harness === 'opencode')) {
         checks.push({