@miadi/connector 0.1.8 → 0.1.10

package/dist/tools.js

@@ -16,8 +16,11 @@ import { reviewIdOf, videoIdOf } from "./reviews.js";
 import { SCOPE_APPROVE, SCOPE_CONTRIBUTE } from "./oauth.js";
 import { CIRCLES, CIRCLE_IDS, CLAIM_CATEGORIES, DOMAINS, HANDOFF_STATES, current, newRecordId, } from "./records.js";
 import { VERSION } from "./version.js";
-import { AlreadyDecided, DECISIONS, KIND_LABELS, consequenceOf, decide, isApprovable, readQueueState } from "./approve.js";
+import { AlreadyDecided, DECISIONS, KIND_LABELS, consequenceOf, decide, isApprovable, readQueueState, requestProjection } from "./approve.js";
 import { DECISIONS_CARD_HTML, DECISIONS_CARD_URI, DECISION_TOKENS_META } from "./decisions.js";
+import { discoverProviders, resolveProvider, routerPreflight, PROVIDERS } from "./providers.js";
+import { missionStatus } from "./mission-status.js";
+import { checkGrant, isBusy, steerAttempts, steeringGrantOf, steerSession } from "./steer.js";
 import { join } from "node:path";
 import { artefactVisibility, readArtefactWeave, saveResearchArtefact } from "@miadi/inquiry-weave";
 import { ResearchUploads, UploadRefusal } from "./uploads.js";
@@ -461,11 +464,79 @@ export function registerTools(server, ctx) {
             record: r,
             approval_url: r.approval_state === "awaiting_approval" ? approvalUrl(r.id) : undefined,
             queue: r.kind === "run_request" || r.kind === "work_proposal" ? readQueueState(r, ctx.factoryDir) : undefined,
+            // Where the request stands, in the words every surface uses (jgwill/Miadi#889).
+            projection: requestProjection(r, { reviewBase: ctx.approval?.config.reviewUrl, factoryDir: ctx.factoryDir }),
             ...(r.approval_state === "revision_requested"
                 ? { revision: { instructions: r.completion_receipt?.instructions, next: `Submit a revised request that cites ${r.id} in refs.` } }
                 : {}),
         };
     }));
+    server.registerTool("mission_status", {
+        title: "Where a mission stands",
+        description: "One mission, joined and verified: its source request and decision, the sessions bound to it (live or not), its issues and PRs, what is approved, queued, delivered, running, merged, released or closed — each by its evidence, never inferred from an idle pane — and the next authorized action. Operator details need Miadi's write tier. jgwill/Miadi#893.",
+        inputSchema: {
+            ref: z
+                .string()
+                .min(1)
+                .describe("run_request:<id>, work_proposal:<id>, another record id, session:<uuid>, or owner/repo#n the mission cites."),
+        },
+        annotations: READ,
+    }, wrap(async ({ ref }, extra) => {
+        const { person } = who(extra);
+        const writeTier = person.api_tier === "write";
+        return missionStatus(ref.trim(), records(), {
+            projectOf: (r) => requestProjection(r, { reviewBase: ctx.approval?.config.reviewUrl, factoryDir: ctx.factoryDir }),
+            queueOf: (r) => (r.kind === "run_request" || r.kind === "work_proposal" ? readQueueState(r, ctx.factoryDir) : undefined),
+            tmuxSessions: writeTier ? (ctx.tmuxSessions ?? (() => [])) : undefined,
+            paneBusy: writeTier && ctx.tmux
+                ? (session) => {
+                    try {
+                        const pane = ctx.tmux.listPanes(session)[0];
+                        if (!pane)
+                            return "unknown";
+                        return isBusy(ctx.tmux.capture(`${session}:${pane.window}.${pane.pane}`)) ? "busy" : "idle";
+                    }
+                    catch {
+                        return "unknown";
+                    }
+                }
+                : undefined,
+            sessionOf: writeTier ? (id) => miadi.get(person.token, `/api/session/${encodeURIComponent(id)}`) : undefined,
+            issueOf: async (owner, repo, n) => {
+                const f = ctx.approval?.fetchImpl ?? fetch;
+                const headers = {
+                    accept: "application/vnd.github+json",
+                    ...(process.env.GITHUB_TOKEN ? { authorization: "Bearer " + process.env.GITHUB_TOKEN } : {}),
+                };
+                const pr = await f(`https://api.github.com/repos/${owner}/${repo}/pulls/${n}`, { headers, signal: AbortSignal.timeout(15_000) });
+                if (pr.ok) {
+                    const p = await pr.json();
+                    return { state: p.state, title: p.title, merged: Boolean(p.merged_at) };
+                }
+                const res = await f(`https://api.github.com/repos/${owner}/${repo}/issues/${n}`, { headers, signal: AbortSignal.timeout(15_000) });
+                if (!res.ok)
+                    return { state: res.status === 404 ? "not_found_or_private" : `github_${res.status}` };
+                const i = await res.json();
+                return { state: i.state, title: i.title };
+            },
+        });
+    }));
+    server.registerTool("provider_capabilities", {
+        title: "Which agent providers this host can launch",
+        description: "The provider reality of the connector host (jgwill/Miadi#893): which agent CLIs are installed, their versions, whether sign-in evidence exists, the preference order (Codex, Pi, Copilot; Claude Code only on explicit request), and the read-only Jev routing preflight. No token is read or shown. Needs Miadi's write tier: this is host truth.",
+        inputSchema: {},
+        annotations: READ,
+    }, wrap(async (_args, extra) => {
+        const { person } = who(extra);
+        requireTier(person, "write");
+        return {
+            preference_order: PROVIDERS.map((p) => p.id),
+            explicit_only: PROVIDERS.filter((p) => !p.selectable_by_default).map((p) => p.id),
+            providers: discoverProviders(ctx.providersProbe),
+            router: await routerPreflight(process.env, ctx.approval?.fetchImpl ?? fetch),
+            note: "A provider name in a task's text selects nothing; request_authorized_run's provider field is verified against this list, and an unavailable provider leaves the mission unstarted.",
+        };
+    }));
     // search / fetch: the pair ChatGPT uses for connectors in search and deep research.
     server.registerTool("search", {
         title: "Search Miadi",
@@ -813,12 +884,31 @@ export function registerTools(server, ctx) {
             refs,
             session: z.string().regex(/^[A-Za-z0-9._-]{3,80}$/).optional().describe("An existing tmux session to hand it to, or a name for a new one."),
             cwd: z.string().max(300).optional().describe("Working folder for a new session (default the Miadi checkout)."),
+            provider: z
+                .enum(["codex", "pi", "copilot", "claude"])
+                .optional()
+                .describe("The provider the run should launch with, verified installed on the connector host. Claude Code runs only when named explicitly. Unknown or unavailable leaves the mission unstarted."),
+            steering: z
+                .object({
+                max_attempts: z.number().int().min(1).max(20).describe("How many authorized follow-up steers this approval covers."),
+                expires_at: z.string().optional().describe("ISO time after which no steer runs under this grant."),
+                pane: z.string().regex(/^\d+\.\d+$/).optional().describe("The pane the seat lives in (window.pane); default the session's first pane."),
+            })
+                .optional()
+                .describe("The steering grant the approver covers with this run: bounded follow-ups to the same session through request_session_steer."),
             ...base,
         },
         annotations: WRITE,
     }, wrap(async (a, extra) => {
         const { person, auth } = who(extra);
         requireContribute(auth);
+        const found = discoverProviders(ctx.providersProbe);
+        const resolution = resolveProvider(a.provider, found);
+        if (resolution.state === "provider_unknown")
+            throw new ToolRefusal("invalid_request", resolution.message, { available: resolution.available });
+        if (resolution.state !== "ok") {
+            return { state: resolution.state, message: resolution.message, available: resolution.available, note: "Nothing was recorded or queued; the mission is unstarted." };
+        }
         const r = append("run_request", person, auth, {
             circle: a.circle,
             refs: a.refs,
@@ -827,9 +917,100 @@ export function registerTools(server, ctx) {
             idempotency_key: a.idempotency_key,
             approval_state: "awaiting_approval",
             state: "pending",
-            body: { task: a.task, session: a.session, cwd: a.cwd },
+            body: {
+                task: a.task,
+                session: a.session,
+                cwd: a.cwd,
+                provider: a.provider,
+                resolved_provider: resolution.provider.id,
+                ...(a.steering ? { steering: a.steering } : {}),
+            },
         });
-        return { ...r, approval_url: approvalUrl(r.id) };
+        return {
+            ...r,
+            provider: { requested: a.provider ?? null, resolved: resolution.provider.id, explicit: resolution.explicit, version: resolution.provider.version },
+            approval_url: approvalUrl(r.id),
+        };
+    }));
+    server.registerTool("request_session_steer", {
+        title: "Send one authorized follow-up to a running agent",
+        description: "Steer one existing live agent session within an approved run's steering grant (jgwill/Miadi#893): the exact instruction is typed into the mission's bound pane — never whichever pane is active — after a peek, and a re-peek verifies the agent accepted it. When the approved run carries no steering grant covering this, the steer waits for one explicit scoped human decision on the returned approval_url. Every attempt leaves a durable artifact with its hash and both captures.",
+        inputSchema: {
+            run_request: z.string().min(1).describe("The approved run_request or work_proposal whose steering grant covers this steer."),
+            instruction: z.string().min(1).max(4000).describe("The exact instruction typed into the session. It is material within the approved mission's scope, not new authority."),
+            session: z.string().regex(/^[A-Za-z0-9._-]{3,80}$/).optional().describe("The session to steer; must be the one the grant binds."),
+            pane: z.string().regex(/^\d+\.\d+$/).optional().describe("The pane (window.pane); default the grant's pane, else the session's first pane. The active pane is never used."),
+            refs,
+            ...base,
+        },
+        annotations: WRITE,
+    }, wrap(async (a, extra) => {
+        const { person, auth } = who(extra);
+        requireContribute(auth);
+        requireTier(person, "write");
+        if (!ctx.tmux)
+            throw new ToolRefusal("unavailable", "The connector host has no steering surface; the steer is unstarted.");
+        const grantRecord = all().find((r) => r.id === a.run_request);
+        if (!grantRecord || (grantRecord.kind !== "run_request" && grantRecord.kind !== "work_proposal")) {
+            throw new ToolRefusal("invalid_ref", "Give the id of the approved run_request or work_proposal this steer belongs to.");
+        }
+        if (grantRecord.approval_state !== "approved") {
+            throw new ToolRefusal("not_approved", `${grantRecord.id} is ${grantRecord.approval_state ?? "not approved"}; a steer needs an approved run's grant or its own human decision.`);
+        }
+        const grant = steeringGrantOf(grantRecord);
+        const priorAttempts = steerAttempts(all(), grantRecord.id);
+        const covered = checkGrant(grant, priorAttempts) === "ok";
+        const body = {
+            instruction: a.instruction,
+            session: a.session ?? grantRecord.body.session,
+            pane: a.pane ?? grant?.pane,
+        };
+        const fields = {
+            circle: grantRecord.circle,
+            refs: [grantRecord.id, ...a.refs],
+            intention: a.intention,
+            role: a.role,
+            idempotency_key: a.idempotency_key,
+            body,
+        };
+        if (!covered) {
+            // One explicit scoped human decision (jgwill/Miadi#893): the record waits
+            // on the approval page; approving it runs exactly this instruction once.
+            const r = append("session_steer_request", person, auth, { ...fields, approval_state: "awaiting_approval", state: "pending" });
+            return {
+                ...r,
+                approval_url: approvalUrl(r.id),
+                state: "awaiting_approval",
+                reason: !grant ? "no_grant" : checkGrant(grant, priorAttempts),
+                message: "The approved run's steering grant does not cover this steer; a person's decision is requested, once, for exactly this instruction.",
+            };
+        }
+        const r = append("session_steer_request", person, auth, { ...fields, approval_state: "not_required" });
+        const result = await steerSession({ tmux: ctx.tmux, stateDir: config.stateDir, ...(ctx.steerSettleMs !== undefined ? { settleMs: ctx.steerSettleMs } : {}) }, { record: r, grantRecord, priorAttempts });
+        const delivered = result.status === "accepted" || result.status === "submitted";
+        ledger.append({
+            id: newRecordId(r.kind),
+            kind: r.kind,
+            created_at: new Date().toISOString(),
+            actor: r.actor,
+            refs: r.refs,
+            evidence_refs: [],
+            supersedes: r.id,
+            approval_state: "not_required",
+            state: delivered ? "completed" : "blocked",
+            completion_receipt: {
+                decision: "covered_by_grant",
+                decided_by: { person_id: person.id, name: person.name },
+                decided_at: new Date().toISOString(),
+                outcome: delivered ? result.status : "failed",
+                steer_status: result.status,
+                message: result.message,
+                ...(result.target ? { target: result.target } : {}),
+                ...(result.artifact ? { artifact: result.artifact } : {}),
+            },
+            body: r.body,
+        });
+        return records().find((x) => x.id === r.id) ?? r;
     }));
     server.registerTool("request_review_operation", {
         title: "Request a review operation",
@@ -1083,9 +1264,9 @@ export function registerTools(server, ctx) {
             const { person, auth } = who(extra);
             const writer = person.api_tier === "write";
             const waiting = all()
-                .filter((r) => r.approval_state === "awaiting_approval" && isApprovable(r))
+                .filter((r) => isApprovable(r))
                 .filter((r) => writer || r.actor.person_id === person.id)
-                .filter((r) => !record_id || r.id === record_id)
+                .filter((r) => record_id ? r.id === record_id : r.approval_state === "awaiting_approval")
                 .slice(-20)
                 .reverse();
             const canDecide = writer && auth.scopes.includes(SCOPE_APPROVE) && Boolean(ctx.decisionTokens);
@@ -1107,17 +1288,20 @@ export function registerTools(server, ctx) {
                 consequence: consequenceOf(r),
                 detail: detailOf(r),
                 approval_url: approvalUrl(r.id),
+                projection: requestProjection(r, { reviewBase: ctx.approval?.config.reviewUrl, factoryDir: ctx.factoryDir }),
             }));
-            const tokens = canDecide ? Object.fromEntries(waiting.map((r) => [r.id, ctx.decisionTokens.issue(r.id, person.id, auth.clientId)])) : {};
+            const actionable = decisions.filter((d) => d.projection?.stage === "awaiting_decision");
+            const tokens = canDecide ? Object.fromEntries(actionable.map((r) => [r.id, ctx.decisionTokens.issue(r.id, person.id, auth.clientId)])) : {};
             const structured = {
                 decisions,
                 count: decisions.length,
+                awaiting_count: actionable.length,
                 can_decide_here: canDecide,
                 ...(reason ? { reason } : {}),
                 ...(decisions.length ? {} : { message: record_id ? "That request is not awaiting a decision." : "No request is waiting for a decision." }),
             };
             const text = decisions.length
-                ? `${decisions.length} request(s) await a decision and are shown as cards. ${canDecide ? "The person decides each one on its card; do not decide or claim a decision for them." : reason}`
+                ? `${decisions.length} request(s) shown as cards; ${actionable.length} await a decision. ${canDecide ? "The person decides an awaiting request on its card; do not decide or claim a decision for them." : reason}`
                 : structured.message;
             return { structuredContent: structured, content: [{ type: "text", text }], _meta: { [DECISION_TOKENS_META]: tokens } };
         }
@@ -1153,28 +1337,43 @@ export function registerTools(server, ctx) {
             const check = ctx.decisionTokens.verify(a.decision_token, r.id, person.id, auth.clientId);
             if (check !== "ok")
                 throw new ToolRefusal(check === "expired" ? "token_expired" : "invalid_token", check === "expired" ? "This card is too old; show the requests again." : "This decision did not come from the person's card.");
-            if (r.approval_state !== "awaiting_approval")
-                throw new ToolRefusal("already_decided", `This request is already ${r.approval_state}.`);
+            // A stale card or a second client gets where the request stands, not a bare refusal (jgwill/Miadi#889).
+            const projectionNow = () => requestProjection(all().find((x) => x.id === r.id) ?? r, { reviewBase: ctx.approval?.config.reviewUrl, factoryDir: ctx.factoryDir });
+            if (r.approval_state !== "awaiting_approval") {
+                throw new ToolRefusal("already_decided", `This request is already ${r.approval_state}.`, { projection: projectionNow() });
+            }
             const instructions = a.instructions?.trim() || undefined;
             if ((a.decision === "approve_with_changes" || a.decision === "request_revision") && !instructions) {
                 throw new ToolRefusal("instructions_required", a.decision === "request_revision" ? "Say what to revise." : "Write the changes to apply.");
             }
             const client = ctx.oauthState.read().clients[auth.clientId];
-            const { decision, state, receipt } = await decide(r, person, a.decision, ctx.approval, {
-                instructions,
-                via: `card:${String(client?.client_name ?? auth.clientId).slice(0, 50)}`,
-            });
+            let decided;
+            try {
+                decided = await decide(r, person, a.decision, ctx.approval, {
+                    instructions,
+                    via: `card:${String(client?.client_name ?? auth.clientId).slice(0, 50)}`,
+                });
+            }
+            catch (error) {
+                // A decision recorded a moment earlier, by another client, is reported with where it stands.
+                if (error instanceof AlreadyDecided)
+                    throw new ToolRefusal("already_decided", error.message, { projection: projectionNow() });
+                throw error;
+            }
+            const { decision, state, receipt } = decided;
+            const projection = projectionNow();
             const summary = decision === "approved"
                 ? `Approved by ${person.name}. ${receipt.outcome === "failed" ? "Running it failed; see the receipt." : `Outcome: ${String(receipt.outcome ?? "recorded").replace(/_/g, " ")}.`}`
                 : decision === "revision_requested"
                     ? `Sent back for revision by ${person.name}.`
                     : `Declined by ${person.name}.`;
-            const out = { record_id: r.id, decision, state, summary, receipt };
+            const out = { record_id: r.id, decision, state, summary, receipt, projection };
             return { structuredContent: out, content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
         }
         catch (error) {
             if (error instanceof ToolRefusal || error instanceof AlreadyDecided) {
-                const out = error instanceof AlreadyDecided ? { error: "already_decided", message: error.message } : { error: error.code, message: error.message };
+                const detail = error instanceof ToolRefusal ? error.detail : undefined;
+                const out = error instanceof AlreadyDecided ? { error: "already_decided", message: error.message } : { error: error.code, message: error.message, ...detail };
                 return { isError: true, structuredContent: out, content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
             }
             return fail({ error: "failed", message: error instanceof Error ? error.message : String(error) });
@@ -1242,6 +1441,8 @@ export const TOOL_STATUS = {
     handoff_status: "live",
     list_records: "live",
     get_run_result: "live",
+    mission_status: "live (operator details need the Miadi write tier)",
+    provider_capabilities: "live, Miadi write tier",
     search: "live",
     fetch: "live",
     append_observation: "live, contribute",
@@ -1255,7 +1456,8 @@ export const TOOL_STATUS = {
     propose_work: "live, contribute, needs_approval (approving starts the work as a factory run)",
     prepare_calendar_event: "live, contribute (draft and .ics only)",
     propose_session_completion: "live, contribute, needs_approval (decision recorded, nothing closed)",
-    request_authorized_run: "live, contribute, needs_approval (queues a factory brief once approved)",
+    request_authorized_run: "live, contribute, needs_approval (queues a factory brief once approved; may name a verified provider and a bounded steering grant)",
+    request_session_steer: "live, contribute, write tier (runs inside an approved run's steering grant, else one scoped human decision)",
     request_review_operation: "live, contribute, needs_approval",
     request_deep_diver: "live, contribute, needs_approval",
     link_review_to_episode: "live, contribute, needs_approval",

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.7";
+export declare const VERSION = "0.1.10";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.1.7";
+export const VERSION = "0.1.10";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miadi/connector",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "The Miadi connector: one remote MCP service through which a person signed in with their Miadi person token, from ChatGPT or any MCP client, reads sessions, reviews, episodes and circles and records observations, inquiries, handoffs and proposals with their name on each record.",
   "license": "MIT",
   "author": "Miadi",
@@ -26,7 +26,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@miadi/inquiry-weave": "0.18.4",
+    "@miadi/inquiry-weave": "0.18.5",
     "@miadi/node-service-kit": "0.1.2",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "express": "^5.2.1",