@minionry/minion 0.7.36 → 0.7.39

package/dist/server/services/plan/review-outcome.js

@@ -0,0 +1,146 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { MAX_REVIEW_ATTEMPTS, } from './types.js';
+const DEFAULT_CONFIDENCE = 'medium';
+export const REVIEW_CONFIDENCES = ['high', 'medium', 'low'];
+export const REVIEW_BLOCKER_KINDS = [
+    'needs_privileged_command',
+    'needs_credentials',
+    'missing_dependency',
+    'external_service',
+    'contradictory_criteria',
+    'out_of_scope_environment',
+    'no_progress',
+];
+const BLOCKER_SUMMARY = {
+    needs_privileged_command: 'needs a privileged (sudo/root) command no agent can run here',
+    needs_credentials: 'needs a credential or account this Space does not hold',
+    missing_dependency: 'needs a package, service or device that is not available here',
+    external_service: 'depends on an external service that is unavailable here',
+    contradictory_criteria: 'its acceptance criteria contradict each other or the code they name',
+    out_of_scope_environment: 'the work cannot be done by an agent in this environment',
+    no_progress: 'two review attempts failed identically — the retry loop is not converging',
+};
+export function parseReviewConfidence(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return REVIEW_CONFIDENCES.includes(normalized)
+        ? normalized
+        : DEFAULT_CONFIDENCE;
+}
+export function parseBlockerKind(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return REVIEW_BLOCKER_KINDS.includes(normalized)
+        ? normalized
+        : null;
+}
+export function parseReviewBlocker(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const raw = value;
+    const kind = parseBlockerKind(raw.kind);
+    if (!kind)
+        return null;
+    const detail = String(raw.detail ?? '').trim();
+    if (!detail)
+        return null;
+    const humanAction = String(raw.humanAction ?? raw.human_action ?? '').trim();
+    return { kind, detail, ...(humanAction ? { humanAction } : {}) };
+}
+export function reviewDisposition(result) {
+    if (result.passed)
+        return 'pass';
+    if (result.disposition === 'blocked' && result.blocker)
+        return 'blocked';
+    return 'revise';
+}
+export function reviewConfidence(result) {
+    return result.confidence ?? DEFAULT_CONFIDENCE;
+}
+export function shouldEscalate(result, isIncomplete) {
+    if (isIncomplete)
+        return false;
+    if (reviewDisposition(result) === 'blocked')
+        return true;
+    return reviewConfidence(result) === 'low';
+}
+export function failureFingerprint(result) {
+    const failed = result.checks.filter((check) => !check.passed);
+    const entries = failed.map((check) => ({ name: check.name, reason: normalizeReason(check) }));
+    if (entries.every((entry) => entry.reason.length === 0))
+        return '';
+    return entries.map((entry) => `${entry.name}:${entry.reason}`).sort().join('|');
+}
+export function isRepeatFailure(previous, current) {
+    if (!previous || previous.passed || current.passed)
+        return false;
+    const before = failureFingerprint(previous);
+    return before.length > 0 && before === failureFingerprint(current);
+}
+export function decideReviewRecovery(result, previous, attemptsBefore) {
+    const attempts = attemptsBefore + 1;
+    if (result.passed)
+        return { action: 'complete', reason: 'Review passed', attempts };
+    const blocker = reviewDisposition(result) === 'blocked' ? result.blocker : undefined;
+    if (blocker) {
+        return {
+            action: 'abandon',
+            reason: `Cannot pass review — ${BLOCKER_SUMMARY[blocker.kind]}: ${blocker.detail}`,
+            blocker,
+            attempts,
+        };
+    }
+    if (isRepeatFailure(previous, result)) {
+        const noProgress = {
+            kind: 'no_progress',
+            detail: `Review attempts ${attempts - 1} and ${attempts} failed the same checks (${failedNames(result).join(', ')}) for the same reasons.`,
+            humanAction: 'Re-scope the issue or fix it by hand — re-running it unchanged will fail the same way.',
+        };
+        return {
+            action: 'abandon',
+            reason: `Cannot pass review — ${BLOCKER_SUMMARY.no_progress}: ${failedNames(result).join(', ')} failed identically twice.`,
+            blocker: noProgress,
+            attempts,
+        };
+    }
+    if (attempts >= MAX_REVIEW_ATTEMPTS) {
+        return {
+            action: 'abandon',
+            reason: `Review failed ${attempts} times — cancelled to unblock dependents; the issue likely needs restructuring`,
+            attempts,
+        };
+    }
+    return { action: 'retry', reason: `Review failed: ${failedNames(result).join(', ')}`, attempts };
+}
+export function failedNames(result) {
+    return result.checks.filter((check) => !check.passed).map((check) => check.name);
+}
+const HEADING_RE = /^#{1,6}[ \t]+\S/;
+const BLOCKED_HEADING_RE = /^#{1,6}[ \t]*blocked\b/i;
+export function parseAgentBlockedReport(text) {
+    const body = blockedSectionBody(text);
+    if (!body)
+        return null;
+    const kind = parseBlockerKind(body.match(/^[ \t]*[-*]?[ \t]*kind[ \t]*:[ \t]*`?([a-z_]+)`?/im)?.[1]);
+    if (!kind || kind === 'no_progress')
+        return null;
+    const reason = (body.match(/^[ \t]*[-*]?[ \t]*reason[ \t]*:[ \t]*(.+)$/im)?.[1] ?? '').trim().replace(/`/g, '');
+    return reason ? { kind, reason: reason.slice(0, 600) } : null;
+}
+function blockedSectionBody(text) {
+    const lines = text.split('\n');
+    const start = lines.findIndex((line) => BLOCKED_HEADING_RE.test(line));
+    if (start === -1)
+        return null;
+    const rest = lines.slice(start + 1);
+    const end = rest.findIndex((line) => HEADING_RE.test(line));
+    return (end === -1 ? rest : rest.slice(0, end)).join('\n');
+}
+function normalizeReason(check) {
+    const source = (check.remediation ?? '').trim() || check.details;
+    return source
+        .toLowerCase()
+        .replace(/\d+/g, '#')
+        .replace(/[^a-z#]+/g, ' ')
+        .trim()
+        .slice(0, 400);
+}

package/dist/server/services/plan/review-report.js

@@ -33,8 +33,19 @@ export function toReviewReport(result) {
         reviewedAt: result.reviewedAt,
         autoPass: result.autoPass === true,
         incompleteReason: verdict === 'incomplete' ? (checks[0]?.details ?? '').trim() : '',
+        reviewedBy: describeRunner(result.reviewedBy),
+        escalatedFrom: result.escalatedFrom ? `escalated from ${result.escalatedFrom.model}` : '',
+        confidence: result.confidence ? `${result.confidence} confidence` : '',
+        blocked: result.disposition === 'blocked' && result.blocker
+            ? `${result.blocker.kind}: ${result.blocker.detail}${result.blocker.humanAction ? ` To unblock: ${result.blocker.humanAction}` : ''}`
+            : '',
     };
 }
+function describeRunner(runner) {
+    if (!runner)
+        return '';
+    return runner.effortLevel === 'auto' ? runner.model : `${runner.model} at ${runner.effortLevel} effort`;
+}
 const VERDICT_TITLES = {
     passed: '✅ Review passed',
     failed: '❌ Review failed',
@@ -47,6 +58,9 @@ export class MarkdownReviewReportRenderer {
             lines.push(report.incompleteReason || 'The reviewer returned no verdict.', '', 'Nothing was marked done — the issue stays in review for a retry.', '');
             return lines.join('\n');
         }
+        if (report.blocked) {
+            lines.push(`**This issue cannot pass review as written** — ${report.blocked}`, '', 'It has been cancelled with that reason recorded rather than re-dispatched.', '');
+        }
         for (const section of report.sections)
             lines.push(...renderSection(section));
         return lines.join('\n');
@@ -72,6 +86,8 @@ function toSection(check) {
         label: reviewCheckLabel(check.name),
         passed: check.passed,
         details: (check.details ?? '').trim(),
+        evidence: (check.evidence ?? '').trim(),
+        remediation: (check.remediation ?? '').trim(),
     };
 }
 function subtitle(report) {
@@ -85,6 +101,12 @@ function subtitle(report) {
         parts.push(`**${failed} of ${report.totalCount} checks failed**${named}`);
     }
     parts.push(report.issueType === 'code' ? 'code review' : 'quality review');
+    if (report.reviewedBy)
+        parts.push(report.reviewedBy);
+    if (report.escalatedFrom)
+        parts.push(report.escalatedFrom);
+    if (report.confidence)
+        parts.push(report.confidence);
     if (report.autoPass)
         parts.push('_auto-passed on an infrastructure failure_');
     const when = formatReviewedAt(report.reviewedAt);
@@ -95,7 +117,12 @@ function subtitle(report) {
 function renderSection(section) {
     const head = `#### ${section.passed ? '✅' : '❌'} ${section.label}`;
     const body = section.details ? renderDetailBody(section.details) : ['_The reviewer gave no reason._'];
-    return [head, '', ...body, ''];
+    const cited = [];
+    if (section.evidence)
+        cited.push('', `*Evidence:* ${section.evidence}`);
+    if (section.remediation)
+        cited.push('', `*To fix:* ${section.remediation}`);
+    return [head, '', ...body, ...cited, ''];
 }
 export function renderDetailBody(details) {
     const facets = splitEnumeratedFacets(details);

package/dist/server/services/plan/review-target.js

@@ -0,0 +1,57 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { engineForModel, parseEngineId } from '../../engines/types.js';
+export const REVIEW_GATE_ENGINE = 'claude-code';
+export const REVIEW_GATE_MODEL = 'fable';
+export const REVIEW_GATE_EFFORT_LEVEL = 'high';
+export const REVIEW_ESCALATION_EFFORT_LEVEL = 'xhigh';
+const CLAUDE_REVIEW_LADDER = ['haiku', 'sonnet', 'opus', 'fable'];
+const REVIEW_EFFORT_BY_MODEL = {
+    haiku: 'auto',
+    sonnet: 'high',
+    opus: 'high',
+    fable: 'high',
+};
+export function resolveReviewTarget(issue) {
+    const named = normalizeModel(issue.reviewModel);
+    if (named)
+        return buildTarget(named, issue.reviewEffort, 'issue', issue.engine);
+    const executionModel = normalizeModel(issue.model);
+    if (executionModel)
+        return buildTarget(executionModel, issue.reviewEffort, 'execution-model', issue.engine);
+    return buildTarget(REVIEW_GATE_MODEL, issue.reviewEffort, 'floor', null);
+}
+export function escalatedReviewTarget(primary) {
+    const rung = CLAUDE_REVIEW_LADDER.indexOf(primary.model);
+    const next = rung === -1 ? -1 : rung + 1;
+    if (next <= 0 || next >= CLAUDE_REVIEW_LADDER.length)
+        return null;
+    const model = CLAUDE_REVIEW_LADDER[next];
+    return {
+        engine: engineForModel(model),
+        model,
+        effortLevel: REVIEW_ESCALATION_EFFORT_LEVEL,
+        source: 'escalation',
+    };
+}
+export function describeReviewTarget(target) {
+    return target.effortLevel === 'auto'
+        ? `${target.model} at its default effort`
+        : `${target.model} at ${target.effortLevel} effort`;
+}
+export function toReviewRunner(target) {
+    return { engine: target.engine, model: target.model, effortLevel: target.effortLevel };
+}
+function normalizeModel(value) {
+    const trimmed = (value ?? '').trim();
+    if (!trimmed || trimmed.toLowerCase() === 'default')
+        return null;
+    return trimmed.toLowerCase();
+}
+function buildTarget(model, reviewEffort, source, issueEngine) {
+    const derived = engineForModel(model);
+    const declared = parseEngineId(issueEngine);
+    const engine = declared === derived ? declared : derived;
+    const effort = (reviewEffort ?? '').trim() || REVIEW_EFFORT_BY_MODEL[model] || REVIEW_GATE_EFFORT_LEVEL;
+    return { engine, model, effortLevel: effort, source };
+}

package/dist/server/services/plan/state-reconciler.js

@@ -13,7 +13,7 @@ function categorizeIssues(issues, issueByPath) {
     for (const issue of issues) {
         if (issue.type === 'epic')
             continue;
-        if (issue.status === 'in_progress' || issue.status === 'in_review') {
+        if (issue.status === 'in_progress' || issue.status === 'in_review' || issue.status === 'awaiting_approval') {
             inProgress.push(issue);
         }
         else if (issue.blockedBy.length > 0 && issue.status !== 'done' && issue.status !== 'cancelled') {
@@ -87,7 +87,7 @@ function deriveEpicStatus(epic, issueByPath) {
     const allFinished = childStatuses.every(s => s === 'done' || s === 'cancelled');
     if (allFinished)
         return 'done';
-    const anyStarted = childStatuses.some(s => s === 'in_progress' || s === 'in_review');
+    const anyStarted = childStatuses.some(s => s === 'in_progress' || s === 'in_review' || s === 'awaiting_approval');
     if (anyStarted && epic.status !== 'in_progress')
         return 'in_progress';
     return null;
@@ -118,7 +118,7 @@ function deriveSprintStatus(sprint, issueByPath) {
     const allFinished = statuses.every(s => s === 'done' || s === 'cancelled');
     if (allFinished)
         return 'completed';
-    const anyStarted = statuses.some(s => s === 'in_progress' || s === 'in_review');
+    const anyStarted = statuses.some(s => s === 'in_progress' || s === 'in_review' || s === 'awaiting_approval');
     if (anyStarted)
         return 'active';
     return null;

package/dist/server/services/plan/template-diff.js

@@ -63,6 +63,8 @@ const ISSUE_DIFF_FIELDS = [
     'model',
     'effort_level',
     'fast_mode',
+    'review_model',
+    'review_effort',
 ];
 function valuesEqual(a, b) {
     if (a === b)

package/dist/server/services/plan/template-instantiator.js

@@ -251,6 +251,10 @@ function renderIssueFrontMatter(issue, title, refs, created) {
         lines.push(`effort_level: ${issue.effort_level}`);
     if (issue.fast_mode != null)
         lines.push(`fast_mode: ${issue.fast_mode}`);
+    if (issue.review_model)
+        lines.push(`review_model: ${issue.review_model}`);
+    if (issue.review_effort)
+        lines.push(`review_effort: ${issue.review_effort}`);
     lines.push('---');
     return lines.join('\n');
 }

package/dist/server/services/plan/watcher.js

@@ -1,7 +1,17 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createHash } from 'node:crypto';
 import { watch } from 'node:fs';
 import { parsePlanDirectory, resolvePmDir } from './parser.js';
+const lastPlanStateDigest = new Map();
+export function broadcastPlanStateIfChanged(ctx, workingDir, state) {
+    const digest = createHash('sha1').update(JSON.stringify(state)).digest('base64');
+    if (lastPlanStateDigest.get(workingDir) === digest)
+        return false;
+    lastPlanStateDigest.set(workingDir, digest);
+    ctx.broadcastToAll({ type: 'planStateUpdated', data: state });
+    return true;
+}
 export class PlanWatcher {
     watcher = null;
     debounceTimer = null;
@@ -56,7 +66,7 @@ export class PlanWatcher {
         try {
             const fullState = parsePlanDirectory(this.workingDir);
             if (fullState) {
-                this.ctx.broadcastToAll({ type: 'planStateUpdated', data: fullState });
+                broadcastPlanStateIfChanged(this.ctx, this.workingDir, fullState);
                 for (const listener of this.updateListeners) {
                     try {
                         listener();

package/dist/server/services/platform-reconnect.js

@@ -5,6 +5,7 @@ export const RELAY_CLOSE = {
     AUTH_EXPIRED: 4008,
     ORCHESTRA_ELSEWHERE: 4013,
     SUPERSEDED: 4015,
+    RELAY_HANDOFF: 4016,
     SERVER_ERROR: 4500,
 };
 export function classifyClose(code, reason, opts) {
@@ -14,10 +15,13 @@ export function classifyClose(code, reason, opts) {
         return 'protocol_too_old';
     if (code === RELAY_CLOSE.SUPERSEDED)
         return 'superseded';
+    if (code === RELAY_CLOSE.RELAY_HANDOFF)
+        return 'handoff';
     if (code === RELAY_CLOSE.AUTH_FAILED || reason?.includes('Unauthorized'))
         return 'auth_failed';
     return 'reconnect';
 }
+export const HANDOFF_RECONNECT_MAX_MS = 1_000;
 export class ReconnectPolicy {
     attempts = 0;
     pairedAt = null;
@@ -44,6 +48,9 @@ export class ReconnectPolicy {
         const jitter = base * this.jitterRatio * (2 * this.random() - 1);
         return Math.max(0, Math.round(base + jitter));
     }
+    handoffDelayMs() {
+        return Math.round(this.random() * HANDOFF_RECONNECT_MAX_MS);
+    }
     reset() {
         this.attempts = 0;
     }

package/dist/server/services/platform-token-lifecycle.js

@@ -1,6 +1,7 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 import { getCredentials, shouldRefreshToken, updateCredentials, } from './platform-credentials.js';
+import { relayHttp } from './relay-http-client.js';
 const PERIODIC_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 export class TokenLifecycle {
     deps;
@@ -48,7 +49,7 @@ export class TokenLifecycle {
         if (!creds?.token)
             return false;
         try {
-            const response = await fetch(`${this.deps.platformUrl}/api/auth/device/verify`, {
+            const response = await (this.deps.http ?? relayHttp).fetch(`${this.deps.platformUrl}/api/auth/device/verify`, {
                 method: 'POST',
                 headers: { 'Authorization': `Bearer ${creds.token}` },
             });