@jack200714/mafw 4.5.1

package/gateway/dist/mobile/push-gateway.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushGateway = void 0;
+const ws_1 = __importDefault(require("ws"));
+class PushGateway {
+    store;
+    onlineDevices = new Map();
+    lastGlobalSend = 0;
+    globalMinIntervalMs = 1000; // 1 msg/s global rate limit
+    perDeviceMinIntervalMs = 1000; // 1 msg/s per-device rate limit
+    deviceLastSend = new Map();
+    constructor(store) {
+        this.store = store;
+    }
+    registerDevice(input) {
+        return this.store.register(input);
+    }
+    listDevices() {
+        return this.store.list();
+    }
+    removeDevice(id) {
+        const ok = this.store.remove(id);
+        if (ok)
+            this.removeOnlineWs(id);
+        return ok;
+    }
+    getDevice(id) {
+        return this.store.get(id);
+    }
+    addOnlineWs(deviceId, ws) {
+        this.onlineDevices.set(deviceId, { ws, lastSeen: Date.now() });
+        // Sync persisted lastSeen so DeviceStore.pruneStale() doesn't evict active devices.
+        this.store.touch(deviceId);
+    }
+    removeOnlineWs(deviceId) {
+        this.onlineDevices.delete(deviceId);
+    }
+    isOnline(deviceId) {
+        return this.onlineDevices.has(deviceId);
+    }
+    setLastSeen(deviceId, ts) {
+        const entry = this.onlineDevices.get(deviceId);
+        if (entry)
+            entry.lastSeen = ts;
+    }
+    cleanupStale(thresholdMs) {
+        const now = Date.now();
+        for (const [id, entry] of this.onlineDevices) {
+            if (now - entry.lastSeen > thresholdMs) {
+                this.onlineDevices.delete(id);
+                this.deviceLastSend.delete(id);
+            }
+        }
+    }
+    /** Prune registered devices in DeviceStore that haven't been seen since cutoff. */
+    pruneDeviceStore(cutoffIso) {
+        const removed = this.store.pruneStale(cutoffIso);
+        // Also clean up any online state for pruned devices.
+        for (const id of removed) {
+            this.onlineDevices.delete(id);
+            this.deviceLastSend.delete(id);
+        }
+        return removed;
+    }
+    /**
+     * Sync in-memory lastSeen to DeviceStore for all active devices.
+     * Call periodically (e.g., every 60s) to prevent pruneDeviceStore()
+     * from evicting devices that are actively connected via WS heartbeat.
+     */
+    syncLastSeenToDeviceStore() {
+        for (const [id] of this.onlineDevices) {
+            this.store.touch(id);
+        }
+    }
+    async onBroadcast(event) {
+        const now = Date.now();
+        // Global leaky bucket: block entire broadcast if last send was <1s ago
+        if (now - this.lastGlobalSend < this.globalMinIntervalMs) {
+            return;
+        }
+        const frame = JSON.stringify({ ...event, timestamp: new Date().toISOString() });
+        let sent = false;
+        for (const [deviceId, entry] of this.onlineDevices) {
+            // Per-device rate limit
+            const lastSend = this.deviceLastSend.get(deviceId) || 0;
+            if (now - lastSend < this.perDeviceMinIntervalMs) {
+                continue;
+            }
+            // 3x exponential backoff on send failure
+            let delivered = false;
+            for (let attempt = 0; attempt < 3; attempt++) {
+                if (entry.ws.readyState !== ws_1.default.OPEN)
+                    break;
+                try {
+                    entry.ws.send(frame);
+                    delivered = true;
+                    break;
+                }
+                catch {
+                    if (attempt < 2) {
+                        const delay = Math.pow(2, attempt) * 100; // 100ms, 200ms
+                        await new Promise((r) => setTimeout(r, delay));
+                    }
+                }
+            }
+            if (delivered) {
+                this.deviceLastSend.set(deviceId, now);
+                sent = true;
+            }
+            else {
+                this.onlineDevices.delete(deviceId);
+            }
+        }
+        if (sent) {
+            this.lastGlobalSend = now;
+        }
+    }
+    destroy() {
+        this.onlineDevices.clear();
+        this.deviceLastSend.clear();
+    }
+}
+exports.PushGateway = PushGateway;

package/gateway/dist/mobile/tts-artifact.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Mobile TTS artifact playback — token-authed alternative to the
+ * loopback-only GET /a2a/artifacts/:id for synthesized TTS audio.
+ *
+ * Endpoint:
+ *   GET /api/mobile/tts/artifacts/:id — stream artifact bytes
+ *
+ * Security:
+ *   - Auth handled by gateway's authorize() middleware (Bearer/x-api-token/?token=;
+ *     loopback passes) — /a2a/artifacts stays loopback-only (AGENTS.md §5.14)
+ *   - Only serves bytes from the in-process ArtifactStore (no URL fetch, no SSRF)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTtsArtifactHandler = createTtsArtifactHandler;
+/**
+ * Creates a request handler for the mobile TTS artifact route.
+ * Returns true if the request was handled, false if not matched.
+ */
+function createTtsArtifactHandler(deps) {
+    const { agent } = deps;
+    return async (req, res) => {
+        const match = req.url?.match(/^\/api\/mobile\/tts\/artifacts\/([^/?]+)(?:\?|$)/);
+        if (!match || req.method !== 'GET')
+            return false;
+        try {
+            const artifact = agent.getArtifact(match[1]);
+            if (!artifact) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'artifact not found' }));
+                return true;
+            }
+            const b64 = artifact.dataUrl.split(',')[1] || '';
+            res.writeHead(200, { 'Content-Type': artifact.mediaType });
+            res.end(Buffer.from(b64, 'base64'));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err?.message || String(err) }));
+        }
+        return true;
+    };
+}

package/gateway/dist/opencode-adapter.js

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * OpencodeAdapter - 适配层，隔离上层代码与 opencode SDK 版本变化
+ *
+ * 设计目标：
+ * 1. 扁平参数：{ sessionID, parts } 而非 { path: { id }, body: { parts } }
+ * 2. 自动解包：内部处理 result.data ?? result
+ * 3. 便捷参数：message 自动转为 parts
+ * 4. 统一接口：消除 v1 嵌套 vs langgraph 扁平两种风格
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpencodeAdapter = createOpencodeAdapter;
+// ─── 工具函数 ───────────────────────────────────────────────
+function unwrap(result) {
+    if (result?.data !== undefined)
+        return result.data;
+    return result;
+}
+function messageToParts(message, parts) {
+    if (parts && parts.length > 0)
+        return parts;
+    if (message)
+        return [{ type: 'text', text: message }];
+    return [];
+}
+// ─── 适配层实现 ─────────────────────────────────────────────
+async function createOpencodeAdapter(config) {
+    const { createOpencodeClient } = await import('@opencode-ai/sdk/v2');
+    const client = createOpencodeClient(config);
+    return {
+        session: {
+            async create(opts) {
+                const result = await client.session.create({
+                    directory: opts.directory,
+                });
+                return unwrap(result);
+            },
+            async promptAsync(opts) {
+                const parts = messageToParts(opts.message, opts.parts);
+                await client.session.promptAsync({
+                    sessionID: opts.sessionID,
+                    parts,
+                    agent: opts.agent,
+                    model: opts.model,
+                    variant: opts.variant,
+                    system: opts.system,
+                    noReply: opts.noReply ?? (opts.expectReply === false ? true : undefined),
+                });
+            },
+            async prompt(opts) {
+                const parts = messageToParts(opts.message, opts.parts);
+                const result = await client.session.prompt({
+                    sessionID: opts.sessionID,
+                    parts,
+                    agent: opts.agent,
+                    model: opts.model,
+                    variant: opts.variant,
+                    system: opts.system,
+                    noReply: opts.noReply,
+                });
+                const data = unwrap(result);
+                const info = data?.info;
+                const t = info?.tokens;
+                return {
+                    ...data,
+                    parts: data?.parts ?? [],
+                    finish: info?.finish,
+                    usage: t
+                        ? {
+                            input: t.input ?? 0,
+                            output: t.output ?? 0,
+                            cached: t.cache?.read ?? 0,
+                            reasoning: t.reasoning ?? 0,
+                            costUsd: typeof info?.cost === 'number' ? info.cost : undefined,
+                        }
+                        : undefined,
+                    error: info?.error
+                        ? {
+                            name: info.error.name ?? info.error.type ?? 'Error',
+                            message: info.error.data?.message ?? info.error.message ?? String(info.error),
+                        }
+                        : undefined,
+                };
+            },
+            async messages(opts) {
+                const result = await client.session.messages({
+                    sessionID: opts.sessionID,
+                    limit: opts.limit,
+                    before: opts.before,
+                });
+                const data = unwrap(result);
+                const nextCursor = result?.response?.headers?.get('X-Next-Cursor') || undefined;
+                return { data, nextCursor };
+            },
+            async get(opts) {
+                const result = await client.session.get({
+                    sessionID: opts.sessionID,
+                });
+                return unwrap(result);
+            },
+            async delete(opts) {
+                const result = await client.session.delete({
+                    sessionID: opts.sessionID,
+                });
+                if (result && typeof result === 'object' && 'error' in result && result.error) {
+                    throw new Error(String(result.error));
+                }
+            },
+            async update(opts) {
+                // v2 SDK signature is flat: { sessionID, title }
+                const result = await client.session.update({
+                    sessionID: opts.sessionID,
+                    title: opts.title,
+                });
+                if (result && typeof result === 'object' && 'error' in result && result.error) {
+                    throw new Error(String(result.error));
+                }
+            },
+            async abort(opts) {
+                await client.session.abort({
+                    sessionID: opts.sessionID,
+                });
+            },
+            async list(opts) {
+                const result = await client.session.list({
+                    directory: opts?.directory,
+                });
+                return unwrap(result);
+            },
+            async todo(opts) {
+                const result = await client.session.todo({
+                    sessionID: opts.sessionID,
+                });
+                return unwrap(result);
+            },
+            async children(opts) {
+                const result = await client.session.children({
+                    sessionID: opts.sessionID,
+                });
+                return unwrap(result);
+            },
+            async summarize(opts) {
+                const result = await client.session.summarize({
+                    sessionID: opts.sessionID,
+                    providerID: opts.providerID,
+                    modelID: opts.modelID,
+                });
+                return unwrap(result);
+            },
+            async fork(opts) {
+                const result = await client.session.fork({
+                    sessionID: opts.sessionID,
+                    messageID: opts.messageID,
+                });
+                const session = unwrap(result);
+                return { id: session?.id };
+            },
+            async revert(opts) {
+                const result = await client.session.revert({
+                    sessionID: opts.sessionID,
+                    messageID: opts.messageID,
+                    partID: opts.partID,
+                });
+                if (result && typeof result === 'object' && 'error' in result && result.error) {
+                    throw new Error(String(result.error));
+                }
+            },
+            async unrevert(opts) {
+                const result = await client.session.unrevert({
+                    sessionID: opts.sessionID,
+                });
+                if (result && typeof result === 'object' && 'error' in result && result.error) {
+                    throw new Error(String(result.error));
+                }
+            },
+            async permissionReply(sessionID, requestId, reply, message) {
+                const result = await client.session.permission.reply({
+                    sessionID,
+                    requestID: requestId,
+                    reply,
+                    ...(message ? { message } : {}),
+                });
+                if (result && typeof result === 'object' && 'error' in result && result.error) {
+                    throw new Error(String(result.error));
+                }
+                return true;
+            },
+            question: {
+                async list(opts) {
+                    const result = await client.session.question.list(opts?.directory ? { directory: opts.directory } : undefined);
+                    const data = unwrap(result);
+                    return Array.isArray(data) ? data : data?.items ?? [];
+                },
+                async reply(opts) {
+                    const result = await client.session.question.reply({
+                        requestID: opts.requestID,
+                        answers: opts.answers,
+                    });
+                    if (result && typeof result === 'object' && 'error' in result && result.error) {
+                        throw new Error(String(result.error));
+                    }
+                },
+                async reject(opts) {
+                    const result = await client.session.question.reject({ requestID: opts.requestID });
+                    if (result && typeof result === 'object' && 'error' in result && result.error) {
+                        throw new Error(String(result.error));
+                    }
+                },
+            },
+        },
+        global: {
+            event() {
+                return client.global.event();
+            },
+        },
+        provider: {
+            async list() {
+                const result = await client.provider.list();
+                return unwrap(result);
+            },
+        },
+        app: {
+            async agents() {
+                const result = await client.app.agents();
+                return unwrap(result);
+            },
+        },
+        config: {
+            async get() {
+                const result = await client.config.get();
+                return unwrap(result);
+            },
+            async update(config) {
+                const result = await client.config.update({
+                    config,
+                });
+                return unwrap(result);
+            },
+        },
+    };
+}

package/gateway/dist/orchestration/outcome-recorder.js

@@ -0,0 +1,218 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferFailureKind = inferFailureKind;
+exports.buildFailureSignature = buildFailureSignature;
+exports.recordGoalOutcome = recordGoalOutcome;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const policy_1 = require("./policy");
+const logger_1 = require("../core/utils/logger");
+const EMPTY_TOKENS = { input: 0, output: 0 };
+function inferFailureKind(input) {
+    if (input.verdict === 'PASS')
+        return null;
+    if (input.verdict === 'CANCELLED')
+        return 'user_cancel';
+    if (input.verdict === 'MAX_RETRIES')
+        return 'max_retries';
+    const err = (input.lastError || '').toLowerCase();
+    if (err.includes('archive'))
+        return 'archive_error';
+    if (err.includes('waves.json') || err.includes('plan'))
+        return 'bad_plan';
+    if (err.includes('review report'))
+        return 'review_false_fail';
+    return 'exec_error';
+}
+function buildFailureSignature(inputOrKind, text) {
+    let kind;
+    let errorText;
+    let firstErrorTool;
+    if (typeof inputOrKind === 'object' && inputOrKind !== null) {
+        kind = inputOrKind.kind;
+        errorText = inputOrKind.errorText ?? null;
+        firstErrorTool = inputOrKind.firstErrorTool ?? null;
+    }
+    else {
+        kind = inputOrKind;
+        errorText = text ?? null;
+        firstErrorTool = null;
+    }
+    if (!kind)
+        return null;
+    const raw = errorText || '';
+    const norm = raw
+        .replace(/[0-9a-f]{8,}/gi, '#')
+        .replace(/\d+/g, 'N')
+        .replace(/[^\p{L}\p{N} ]+/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 80);
+    // Extract tool name from error text when not explicitly provided
+    let tool = firstErrorTool;
+    if (!tool) {
+        // Try to extract tool name from common error patterns
+        const m = raw.match(/(?:tool\s+(\w+)|(?:error|failed|exception)\s+(?:in\s+)?(\w+)|(mafw_\w+)|\bexcept(?:ion)?\s+(?:in\s+)?(\w+))/i);
+        const candidate = m ? (m[1] || m[2] || m[3] || m[4]).toLowerCase() : null;
+        // Filter out common prepositions and articles
+        const stopwords = new Set(['in', 'on', 'at', 'to', 'for', 'with', 'from', 'by', 'as', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'shall', 'can', 'need', 'dare', 'ought', 'used', 'a', 'an', 'the', 'and', 'but', 'or', 'nor', 'not', 'so', 'yet', 'both', 'either', 'neither', 'each', 'every', 'all', 'any', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'only', 'own', 'same', 'than', 'too', 'very', 'just', 'because', 'as', 'until', 'while', 'of', 'at', 'by', 'for', 'with', 'about', 'against', 'between', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'to', 'from', 'up', 'down', 'in', 'out', 'on', 'off', 'over', 'under', 'again', 'further', 'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all', 'both', 'each', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very', 's', 't', 'can', 'will', 'just', 'don', 'should', 'now']);
+        tool = candidate && !stopwords.has(candidate) ? candidate : 'unknown';
+    }
+    const textPart = norm || 'no_details';
+    return `${kind}:${tool}:${textPart}`;
+}
+function aggregateTrajectory(db, sessionIds) {
+    if (sessionIds.length === 0)
+        return null;
+    const rawDb = db.db;
+    const placeholders = sessionIds.map(() => '?').join(',');
+    const rows = rawDb.prepare(`SELECT tokens, cost, tool_error_count FROM trajectory_turns WHERE session_id IN (${placeholders})`).all(...sessionIds);
+    if (rows.length === 0)
+        return null;
+    let input = 0, output = 0, cost = 0, toolErrors = 0;
+    for (const r of rows) {
+        const t = r.tokens ? JSON.parse(r.tokens) : EMPTY_TOKENS;
+        input += t.input || 0;
+        output += t.output || 0;
+        cost += r.cost || 0;
+        toolErrors += r.tool_error_count || 0;
+    }
+    return { tokens_input: input, tokens_output: output, total_cost: cost, tool_error_count: toolErrors };
+}
+function aggregateFeedback(projectDir, goalId) {
+    let up = 0, down = 0;
+    const dirs = ['.mafw/feedback', '.mafw/user-feedback'];
+    const seen = new Set();
+    for (const d of dirs) {
+        const dir = path.join(projectDir, d);
+        if (!fs.existsSync(dir))
+            continue;
+        for (const f of fs.readdirSync(dir)) {
+            if (!f.endsWith('.json'))
+                continue;
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+                if (data.goalId !== goalId)
+                    continue;
+                const key = data.feedbackId || f;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                if (data.type === 'thumbs_up')
+                    up++;
+                if (data.type === 'thumbs_down')
+                    down++;
+            }
+            catch { /* skip malformed */ }
+        }
+    }
+    return { thumbs_up: up, thumbs_down: down };
+}
+function readRequestSnapshot(mafwDir, goalId) {
+    try {
+        const p = path.join(mafwDir, 'requests', `${goalId}.json`);
+        if (!fs.existsSync(p))
+            return {};
+        const req = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        return { createdAt: req.createdAt };
+    }
+    catch {
+        return {};
+    }
+}
+function readStateFile(mafwDir, goalId) {
+    try {
+        const p = path.join(mafwDir, 'state', `${goalId}.json`);
+        if (!fs.existsSync(p))
+            return null;
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function getFirstErrorTool(db, sessionIds) {
+    if (sessionIds.length === 0)
+        return null;
+    const rawDb = db.db;
+    const placeholders = sessionIds.map(() => '?').join(',');
+    const row = rawDb.prepare(`SELECT tool_name FROM trajectory_events 
+     WHERE session_id IN (${placeholders}) AND error IS NOT NULL 
+     ORDER BY turn_id ASC, seq ASC LIMIT 1`).get(...sessionIds);
+    return row?.tool_name ?? null;
+}
+function recordGoalOutcome(db, input) {
+    try {
+        const state = readStateFile(input.mafwDir, input.goalId);
+        const snapshot = state?.policySnapshot ?? null;
+        const policy = snapshot ?? (0, policy_1.getActivePolicy)(input.mafwDir);
+        const req = readRequestSnapshot(input.mafwDir, input.goalId);
+        const createdAt = req.createdAt ?? null;
+        const durationMs = createdAt ? Date.now() - new Date(createdAt).getTime() : null;
+        const sessions = db.listGoalSessions(input.goalId);
+        const sessionIds = sessions.map(s => s.session_id);
+        const traj = aggregateTrajectory(db, sessionIds);
+        const fb = aggregateFeedback(input.projectDir, input.goalId);
+        const kind = inferFailureKind(input);
+        const firstErrorTool = getFirstErrorTool(db, sessionIds);
+        db.upsertGoalOutcome({
+            goal_id: input.goalId,
+            project_id: input.projectId,
+            verdict: input.verdict,
+            rounds: input.rounds,
+            duration_ms: durationMs,
+            tokens_input: traj?.tokens_input ?? null,
+            tokens_output: traj?.tokens_output ?? null,
+            total_cost: traj?.total_cost ?? null,
+            tool_error_count: traj?.tool_error_count ?? null,
+            thumbs_up: fb.thumbs_up,
+            thumbs_down: fb.thumbs_down,
+            policy_version: policy.version,
+            evolution_proposal_id: policy.proposalId,
+            failure_kind: kind,
+            failure_signature: buildFailureSignature({
+                kind,
+                errorText: input.lastError ?? input.reviewFeedback,
+                firstErrorTool,
+            }),
+            created_at: createdAt,
+            archived_at: new Date().toISOString(),
+        });
+    }
+    catch (err) {
+        logger_1.log.warn(`[Outcome] recordGoalOutcome failed (non-fatal): ${err.message}`);
+    }
+}

package/gateway/dist/orchestration/policy.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_POLICY = void 0;
+exports.getActivePolicy = getActivePolicy;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.BUILTIN_POLICY = { version: 'builtin-v1', proposalId: null };
+function getActivePolicy(mafwDir) {
+    try {
+        const p = path.join(mafwDir, 'orchestration', 'active.json');
+        if (!fs.existsSync(p))
+            return { ...exports.BUILTIN_POLICY };
+        const data = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        if (typeof data?.version !== 'string' || !data.version)
+            return { ...exports.BUILTIN_POLICY };
+        return {
+            version: data.version,
+            proposalId: typeof data.proposalId === 'string' ? data.proposalId : null,
+        };
+    }
+    catch {
+        return { ...exports.BUILTIN_POLICY };
+    }
+}