@mnemom/mnemom 0.17.3-next.3 → 0.17.3-next.5

package/dist/commands/agent-goal.js

@@ -195,6 +195,13 @@ export function buildGoalShowView(record, body, opts) {
     L.push(fmt.label("verdict:        ", v
         ? `${v.verdict.toUpperCase()} at turn ${v.turn}${v.superseded ? " (superseded)" : ""}`
         : fmt.dim("none yet")));
+    const unverified = body.unverified_mid_turn_messages ?? [];
+    if (unverified.length) {
+        L.push(fmt.label("unverified:     ", fmt.dim("mid-turn messages seen in tool output; they did NOT change the goal")));
+        for (const u of unverified) {
+            L.push(`  ${formatRelativeAge(u.at)}  ${JSON.stringify(u.text)}`);
+        }
+    }
     if (body.threads) {
         L.push(fmt.label("threads:", ""));
         for (const t of body.threads) {

package/dist/commands/agent-sessions.d.ts

@@ -115,6 +115,8 @@ export interface AgentShowOptions {
 /** Why the live read could not happen, from the thrown error. */
 export declare function unavailableReason(err: unknown): string;
 /** `rev N[ · pinned]` from a live show body, or `rev 0 (no goal yet)`. */
+/** Longest goal statement `agent show` prints inline; `mnemom agent goal show` has the full text. */
+export declare const LIVE_GOAL_STATEMENT_MAX = 80;
 export declare function liveGoalLine(body: GoalShowResponse): string;
 /** `mnemom agent show [ref] [--json]` */
 export declare function agentShowCommand(ref: string | undefined, opts: AgentShowOptions, deps: SessionCommandDeps): Promise<void>;

package/dist/commands/agent-sessions.js

@@ -274,10 +274,19 @@ export function unavailableReason(err) {
     return err instanceof Error ? err.message : String(err);
 }
 /** `rev N[ · pinned]` from a live show body, or `rev 0 (no goal yet)`. */
+/** Longest goal statement `agent show` prints inline; `mnemom agent goal show` has the full text. */
+export const LIVE_GOAL_STATEMENT_MAX = 80;
 export function liveGoalLine(body) {
     if (!body.intent)
         return "rev 0 (no goal yet)";
-    return `rev ${body.intent.revision}${body.intent.pinned ? " · pinned" : ""}`;
+    const rev = `rev ${body.intent.revision}${body.intent.pinned ? " · pinned" : ""}`;
+    const statement = body.intent.statement.replace(/\s+/g, " ").trim();
+    if (!statement)
+        return rev;
+    if (statement.length <= LIVE_GOAL_STATEMENT_MAX)
+        return `${rev} — "${statement}"`;
+    const cut = statement.slice(0, LIVE_GOAL_STATEMENT_MAX - 1).trimEnd();
+    return `${rev} — "${cut}…" (full: mnemom agent goal show)`;
 }
 /** `mnemom agent show [ref] [--json]` */
 export async function agentShowCommand(ref, opts, deps) {

package/dist/commands/agents.d.ts

@@ -1,6 +1,9 @@
+import { type OrgListItem } from "../lib/api.js";
 export interface AgentsListOptions {
-    /** Scope to a single org. When omitted, aggregates across every org you belong to. */
+    /** Org slug OR org_id to scope to. Omit → the active org, or every org if none is set. */
     org?: string;
+    /** Aggregate across every org you belong to, ignoring the active org. */
+    all?: boolean;
 }
 export declare function agentsListCommand(options?: AgentsListOptions): Promise<void>;
 export interface AgentsClaimOptions {
@@ -25,6 +28,16 @@ export interface AgentsClaimOptions {
  * derivation (gateway/src/index.ts) and agent-proof.ts on the API side.
  */
 export declare function deriveHashProof(apiKey: string, agentName?: string): string;
+/**
+ * Resolve an `--org <slug>` value to an org_id. Accepts either a slug or a raw
+ * org_id (both are matched against the caller's memberships). Returns the
+ * resolved org_id, or throws a teaching error listing the caller's orgs when
+ * the value matches none of them.
+ */
+export declare function resolveOrgId(slugOrId: string, orgs: OrgListItem[], hint?: {
+    lead: string;
+    tail: string;
+}): string;
 /**
  * `mnemom agent claim <id-or-name> [--org <slug>] (--key <k> | --hash-proof <h>)`
  *

package/dist/commands/agents.js

@@ -15,11 +15,54 @@ export async function agentsListCommand(options = {}) {
         console.log(fmt.dim("  To list org-scoped agents, log in with a session: mnemom login") + "\n");
         return;
     }
+    let scope = { kind: "all" };
+    if (cred.type === "jwt") {
+        if (options.org && options.all) {
+            console.log(fmt.error("Pass --org or --all, not both.") + "\n");
+            process.exit(1);
+            return;
+        }
+        if (options.org) {
+            // Resolve slug-or-id against your memberships BEFORE the fleet read: the
+            // fleet route takes an org_id, so a raw slug there 403s as "Permission denied".
+            let orgs;
+            try {
+                orgs = await listMyOrgs();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.log(fmt.error(`Failed to read your orgs: ${msg}`) + "\n");
+                process.exit(1);
+                return;
+            }
+            try {
+                const orgId = resolveOrgId(options.org, orgs, LIST_ORG_HINT);
+                scope = { kind: "org", orgId, label: options.org.trim() };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.log(fmt.error(msg) + "\n");
+                process.exit(1);
+                return;
+            }
+        }
+        else if (!options.all) {
+            const active = getActiveOrg();
+            if (active) {
+                scope = { kind: "org", orgId: active.org_id, label: active.slug };
+                console.error(fmt.dim(`  Showing active org ${active.name} (${active.slug}) — --all for every org.`) +
+                    "\n");
+            }
+        }
+    }
     // Show the Org column only when a JWT session aggregates across all orgs.
-    const showOrg = cred.type === "jwt" && !options.org;
+    const showOrg = cred.type === "jwt" && scope.kind === "all";
     let agents;
     try {
-        agents = cred.type === "api-key" ? await listAgents() : await listOrgAgents(options.org);
+        agents =
+            cred.type === "api-key"
+                ? await listAgents()
+                : await listOrgAgents(scope.kind === "org" ? scope.orgId : undefined);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -27,7 +70,9 @@ export async function agentsListCommand(options = {}) {
         process.exit(1);
     }
     if (agents.length === 0) {
-        console.log(options.org ? `  No agents found in org '${options.org}'.\n` : "  No agents found.\n");
+        console.log(scope.kind === "org"
+            ? `  No agents found in org '${scope.label}'.\n`
+            : "  No agents found.\n");
         return;
     }
     const nameW = 24;
@@ -87,15 +132,22 @@ export function deriveHashProof(apiKey, agentName) {
  * resolved org_id, or throws a teaching error listing the caller's orgs when
  * the value matches none of them.
  */
-function resolveOrgId(slugOrId, orgs) {
+export function resolveOrgId(slugOrId, orgs, hint = CLAIM_ORG_HINT) {
     const needle = slugOrId.trim();
     const match = orgs.find((o) => o.slug === needle) ?? orgs.find((o) => o.org_id === needle);
     if (match)
         return match.org_id;
     const choices = orgs.map((o) => `    ${o.slug.padEnd(24)} ${o.name}`).join("\n");
-    throw new Error(`No org of yours matches '${needle}'. You can claim into one of:\n${choices}\n` +
-        `  Pass --org <slug>, or omit --org to land in your personal org.`);
+    throw new Error(`No org of yours matches '${needle}'. ${hint.lead}\n${choices}\n  ${hint.tail}`);
 }
+const CLAIM_ORG_HINT = {
+    lead: "You can claim into one of:",
+    tail: "Pass --org <slug>, or omit --org to land in your personal org.",
+};
+const LIST_ORG_HINT = {
+    lead: "Your orgs:",
+    tail: "Pass --org <slug>, or --all for every org.",
+};
 /** The not-a-member 403 code emitted by the merged endpoint. */
 const NOT_A_MEMBER_CODE = "agent_org_not_member";
 /**

package/dist/index.js

@@ -677,11 +677,12 @@ policyCmd
 // ============================================================================
 agentCmd
     .command("list")
-    .description("List agents across the orgs you belong to (ADR-062 org-scoped)")
-    .option("--org <id>", "Scope to a single org (default: all orgs you belong to)")
+    .description("List the agents in your active org (set with `mnemom org use`), or every org you belong to if none is set (ADR-062 org-scoped)")
+    .option("--org <slug-or-id>", "Scope to one org, by slug or id (default: the active org)")
+    .option("--all", "List agents across every org you belong to, ignoring the active org")
     .action(async (opts) => {
     try {
-        await agentsListCommand({ org: opts.org });
+        await agentsListCommand({ org: opts.org, all: opts.all });
     }
     catch (error) {
         console.error("Error:", error instanceof Error ? error.message : error);

package/dist/lib/goal-api.d.ts

@@ -99,6 +99,21 @@ export interface GoalShowResponse {
     verdict: GoalVerdictView | null;
     last_revision: number;
     threads?: GoalThreadRow[];
+    /**
+     * IG4 steer: mid-turn messages found in a tool_result. RECORD ONLY: tool output can forge one,
+     * so they never changed the goal. Absent when there are none.
+     */
+    unverified_mid_turn_messages?: GoalUnverifiedMessage[];
+}
+export interface GoalUnverifiedMessage {
+    /**
+     * Clipped to 500 chars by the gateway. UNTRUSTED: it can be attacker-written tool output, so a
+     * consumer must escape it (the CLI prints it JSON-quoted; a web view must never render it as HTML).
+     */
+    text: string;
+    chars: number;
+    hash: string;
+    at: string;
 }
 export interface GoalPinResponse {
     conversation_id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.3-next.3",
+  "version": "0.17.3-next.5",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {