@crouton-kit/crouter 0.3.3 → 0.3.11

package/dist/core/help.js

@@ -5,6 +5,30 @@
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
+/** Build a self-named runtime-state element: `<tag attr="v">body</tag>`. The
+ *  subtree that owns the state authors it through this, so the tag name and any
+ *  scalar metadata (e.g. a count) travel with the data and render identically
+ *  at every level the block appears. The tag name carries the label, so the
+ *  body never repeats it. Attribute values are controlled (counts, short
+ *  tokens) and not escaped. */
+export function stateBlock(tag, attrs, body) {
+    const a = Object.entries(attrs)
+        .map(([k, v]) => ` ${k}="${v}"`)
+        .join('');
+    return `<${tag}${a}>\n${body}\n</${tag}>`;
+}
+/** Evaluate a dynamicState hook, soft-failing to null on throw or empty. */
+function evalDynamic(fn) {
+    if (fn === undefined)
+        return null;
+    try {
+        const s = fn();
+        return s !== null && s !== '' ? s : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Return the longest string length in an array of names. */
 function maxLen(names) {
     let max = 0;
@@ -23,27 +47,38 @@ function pad(s, width) {
 // ---------------------------------------------------------------------------
 const IO_CONTRACT = 'I/O contract: flags and positional args on input, JSON on stdout (JSONL for streams).\n' +
     'Exit 0 on success, non-zero on failure. Schemas appear at leaf -h.';
+// Behavioral instruction (not a schema) — engrained in the appended system
+// prompt so the model treats unfamiliar capabilities as a cue to discover the
+// contract, never to guess. Lives in the root guide, outside any leaf -h.
+const CAPABILITY_DISCOVERY = "If the user mentions or implies a crtr capability you don't fully understand, " +
+    'do not guess or assume it is unsupported — run `-h` on the relevant command ' +
+    '(append it anywhere along the path) to read the contract before acting.';
 export function renderRoot(h) {
     const lines = [];
     lines.push(`${h.tagline}`);
     lines.push('');
-    // Concepts block
-    lines.push('Concepts');
-    const cNameW = maxLen(h.concepts.map((c) => c.name));
-    for (const c of h.concepts) {
-        lines.push(`  ${pad(c.name, cNameW)}  ${c.desc}`);
-    }
-    lines.push('');
-    // Subtrees block
-    lines.push('Subtrees');
-    const sNameW = maxLen(h.subtrees.map((s) => s.name));
-    // Align desc column so "| use when X" starts at a consistent offset
-    const sDescW = maxLen(h.subtrees.map((s) => s.desc));
-    for (const s of h.subtrees) {
-        lines.push(`  ${pad(s.name, sNameW)}  ${pad(s.desc, sDescW)}  | use when ${s.useWhen}`);
+    // Each subtree is one <command name="…"> block. The uniform wrapper states
+    // "this is a command you invoke as `crtr <name>`" — so the model reads them
+    // by one rule, and a nested state element (which is never a <command>) can't
+    // be mistaken for a sibling command. Inside: the concept (what it is), the
+    // selection rubric (when to pick it), then any self-named state element
+    // grouped with the command it belongs to. Once injected into a system prompt,
+    // each block reads as one self-contained concern domain. Header (tagline) and
+    // footer (Globals + I/O contract + capability-discovery rule) are the only
+    // non-command areas. Two levels of nesting: <command> → <state>.
+    for (const c of h.commands) {
+        lines.push(`<command name="${c.name}">`);
+        lines.push(c.concept);
+        lines.push(`use when ${c.useWhen}`);
+        // dynamicState returns a complete self-named element (e.g.
+        // <skills count="42">…</skills>) — emit it as-is, nested in the command.
+        const state = evalDynamic(c.dynamicState);
+        if (state !== null)
+            lines.push(state);
+        lines.push('</command>');
+        lines.push('');
     }
-    lines.push('');
-    // Globals block
+    // Globals block (footer)
     lines.push('Globals');
     const gNameW = maxLen(h.globals.map((g) => g.name));
     for (const g of h.globals) {
@@ -51,6 +86,8 @@ export function renderRoot(h) {
     }
     lines.push('');
     lines.push(IO_CONTRACT);
+    lines.push('');
+    lines.push(CAPABILITY_DISCOVERY);
     return lines.join('\n');
 }
 // ---------------------------------------------------------------------------
@@ -59,25 +96,20 @@ export function renderRoot(h) {
 export function renderBranch(h) {
     const lines = [];
     lines.push(`${h.name}: ${h.summary}.`);
+    // Dynamic content leads — the live aggregate (e.g. the <skills> catalog)
+    // renders right after the name, before the hardcoded model prose, so current
+    // state is read first. The subtree authors the whole element, so the same
+    // self-named block appears identically at root and at `skill -h`.
+    const branchState = evalDynamic(h.dynamicState);
+    if (branchState !== null) {
+        // dynamicState returns a complete self-named element — emit as-is.
+        lines.push('');
+        lines.push(branchState);
+    }
     if (h.model !== undefined) {
+        lines.push('');
         lines.push(h.model);
     }
-    // Dynamic state — soft-fail to omission. Rendered as its own block,
-    // blank-line separated from the summary, so a multi-line runtime
-    // aggregate (e.g. the loaded-skills catalog) reads cleanly.
-    if (h.dynamicState !== undefined) {
-        let state = null;
-        try {
-            state = h.dynamicState();
-        }
-        catch {
-            // soft-fail: omit the block
-        }
-        if (state !== null && state !== '') {
-            lines.push('');
-            lines.push(state);
-        }
-    }
     lines.push('');
     lines.push('Branches');
     const nameW = maxLen(h.children.map((c) => c.name));

package/dist/core/jobs.d.ts

@@ -1,4 +1,4 @@
-type TerminalStatus = 'done' | 'failed' | 'canceled';
+type TerminalStatus = 'done' | 'failed' | 'canceled' | 'closed';
 type JobState = 'live' | TerminalStatus;
 type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 /**
@@ -16,6 +16,11 @@ export declare function createJob(kind: string, opts: {
  * Record the tmux pane hosting a detached worker so `cancelJob` can kill it.
  */
 export declare function recordJobPane(jobId: string, paneId: string): void;
+/**
+ * Record the pid of a detached worker (e.g. a headless background agent) so
+ * jobStatus can mark the job failed if the process dies without a result.
+ */
+export declare function recordJobPid(jobId: string, pid: number): void;
 /**
  * Append one event line to log.jsonl. Does NOT throw if jobId doesn't exist —
  * a crashed writer should not further corrupt state; use a guard at the call site.
@@ -27,28 +32,43 @@ export declare function appendEvent(jobId: string, event: {
     data?: object;
 }): void;
 /**
- * Atomically write result.json and update meta.json status.
- * result.json's appearance is the ONLY completion signal — never inferred from
- * log content.
+ * Atomically write result.json (structured object) and update meta.json status.
+ * Used by programmatic callers (human, sys) that produce object results.
+ * The result file's appearance is the completion signal — never inferred from log content.
  */
 export declare function writeResult(jobId: string, result: object, terminalStatus: TerminalStatus): void;
 /**
- * Read result.json. If it doesn't exist and waitMs is given, block via fs.watch
- * until result.json appears or the timeout elapses.
+ * Atomically write result.md (YAML frontmatter + markdown body) and update meta.json status.
+ * Used by `crtr job submit` for agent-driven markdown results.
+ */
+export declare function writeMarkdownResult(jobId: string, body: string, terminalStatus: TerminalStatus, reason?: string): void;
+/**
+ * Read whichever result file exists (result.md or result.json). If neither
+ * exists and waitMs is given, block via fs.watch until one appears or the
+ * timeout elapses.
  *
- * Race safety: registers the watcher THEN re-stats. If result.json appeared
+ * Race safety: registers the watcher THEN re-stats. If a result file appeared
  * between the first stat and the watch registration, the re-stat catches it
  * before the watcher has a chance to miss it.
+ *
+ * Returns shape:
+ *   - JSON path:     { status, result: object }
+ *   - Markdown path: { status, result_md: string, reason?: string }
+ *   - Timeout:       { status: 'timeout' }
+ *   - Closed:        pane vanished with no result → status 'closed'
  */
+export interface ReadResultResponse {
+    status: 'done' | 'failed' | 'canceled' | 'closed' | 'timeout';
+    result?: object;
+    result_md?: string;
+    reason?: string;
+}
 export declare function readResult(jobId: string, opts?: {
     waitMs?: number;
-}): Promise<{
-    status: 'done' | 'failed' | 'canceled' | 'timeout';
-    result?: object;
-}>;
+}): Promise<ReadResultResponse>;
 /**
- * Derive job state from meta.json, result.json, and the tail of log.jsonl.
- * If a pid is recorded, is not alive, and no result.json exists → 'failed'.
+ * Derive job state from meta.json, the result file, and the tail of log.jsonl.
+ * If a pid is recorded, is not alive, and no result file exists → 'failed'.
  */
 export declare function jobStatus(jobId: string): {
     state: JobState;

package/dist/core/jobs.js

@@ -6,7 +6,16 @@
 // Layout: ${XDG_STATE_HOME or ~/.local/state}/crtr/jobs/<job_id>/
 //   meta.json    — written atomically on create; updated atomically on terminal transition.
 //   log.jsonl    — append-only event log.
-//   result.json  — written atomically; its APPEARANCE is the only completion signal.
+//   result.md    — agent submissions (markdown body + YAML frontmatter). Written atomically.
+//   result.json  — programmatic submissions (structured object). Written atomically.
+// Either result file's APPEARANCE is the completion signal. Exactly one is written per job.
+//
+// A worker is not required to submit. Besides an explicit submit, a job becomes
+// terminal when (a) the wrapper shell's `crtr job _fail` runs on a clean exit,
+// or (b) the hosting tmux pane is closed — which sends SIGHUP so (a) never runs.
+// Case (b) is reaped here: when a live job's recorded pane is gone and no result
+// exists, we write a `closed` result (terminal, but distinct from `failed`) so
+// the job stops being a zombie without claiming an outcome we can't know.
 import { existsSync, mkdirSync, appendFileSync, readFileSync, writeFileSync, renameSync, readdirSync, statSync, } from 'node:fs';
 import { watch } from 'node:fs';
 import { spawnSync } from 'node:child_process';
@@ -31,9 +40,22 @@ function metaPath(jobId) {
 function logPath(jobId) {
     return join(jobDir(jobId), 'log.jsonl');
 }
-function resultPath(jobId) {
+function resultJsonPath(jobId) {
     return join(jobDir(jobId), 'result.json');
 }
+function resultMdPath(jobId) {
+    return join(jobDir(jobId), 'result.md');
+}
+/** Path of whichever result file currently exists, or null if neither does. */
+function existingResultPath(jobId) {
+    const md = resultMdPath(jobId);
+    if (existsSync(md))
+        return md;
+    const js = resultJsonPath(jobId);
+    if (existsSync(js))
+        return js;
+    return null;
+}
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -72,6 +94,56 @@ function pidAlive(pid) {
         return false;
     }
 }
+/**
+ * Set of every tmux pane id across all sessions on the running server. Empty
+ * when no server is running (→ every recorded pane is treated as gone).
+ *
+ * This bridges tmux's pane lifecycle to the job registry. A worker whose pane
+ * is closed/killed receives SIGHUP, so the wrapper shell's `crtr job _fail`
+ * never runs and the job would otherwise stay `live` forever (a zombie). We
+ * detect the vanished pane and reap the job instead.
+ */
+function allTmuxPaneIds() {
+    const set = new Set();
+    const r = spawnSync('tmux', ['list-panes', '-a', '-F', '#{pane_id}'], { encoding: 'utf8' });
+    if (r.status !== 0 || typeof r.stdout !== 'string')
+        return set;
+    for (const line of r.stdout.split('\n')) {
+        const t = line.trim();
+        if (t !== '')
+            set.add(t);
+    }
+    return set;
+}
+/**
+ * Reap a job whose hosting tmux pane has disappeared. Acts only when the job is
+ * still `live`, has a recorded pane, and has produced no result file. Writes a
+ * terminal `closed` result so the job stops being a zombie and every reader
+ * (status, list, result --wait) agrees. `closed` is distinct from `failed`: we
+ * don't know the outcome, only that the pane is gone. Returns true if it reaped.
+ *
+ * `panes` lets a caller reuse a single tmux query across many jobs (listJobs).
+ */
+function reapIfPaneDead(meta, panes) {
+    if (meta.status !== 'live')
+        return false;
+    if (meta.pane_id === undefined || meta.pane_id === '')
+        return false;
+    if (existingResultPath(meta.job_id) !== null)
+        return false;
+    const set = panes ?? allTmuxPaneIds();
+    if (set.has(meta.pane_id))
+        return false;
+    try {
+        writeMarkdownResult(meta.job_id, '', 'closed', 'worker pane closed before submitting a result');
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+/** Poll cadence (ms) for detecting a closed worker pane during result --wait. */
+const PANE_POLL_MS = 2000;
 const LEVEL_RANK = {
     debug: 0,
     info: 1,
@@ -111,6 +183,15 @@ export function recordJobPane(jobId, paneId) {
     meta.pane_id = paneId;
     writeMeta(jobId, meta);
 }
+/**
+ * Record the pid of a detached worker (e.g. a headless background agent) so
+ * jobStatus can mark the job failed if the process dies without a result.
+ */
+export function recordJobPid(jobId, pid) {
+    const meta = readMeta(jobId);
+    meta.pid = pid;
+    writeMeta(jobId, meta);
+}
 /**
  * Append one event line to log.jsonl. Does NOT throw if jobId doesn't exist —
  * a crashed writer should not further corrupt state; use a guard at the call site.
@@ -129,9 +210,9 @@ export function appendEvent(jobId, event) {
     appendFileSync(p, JSON.stringify(line) + '\n', 'utf8');
 }
 /**
- * Atomically write result.json and update meta.json status.
- * result.json's appearance is the ONLY completion signal — never inferred from
- * log content.
+ * Atomically write result.json (structured object) and update meta.json status.
+ * Used by programmatic callers (human, sys) that produce object results.
+ * The result file's appearance is the completion signal — never inferred from log content.
  */
 export function writeResult(jobId, result, terminalStatus) {
     const dir = jobDir(jobId);
@@ -143,87 +224,205 @@ export function writeResult(jobId, result, terminalStatus) {
         result,
         written_at: new Date().toISOString(),
     };
-    // Atomic write: tmp + rename within same directory (same fs, rename is atomic).
     const tmp = join(dir, '.result.tmp');
     writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
-    renameSync(tmp, resultPath(jobId));
-    // Update meta status.
+    renameSync(tmp, resultJsonPath(jobId));
     const meta = readMeta(jobId);
     meta.status = terminalStatus;
     writeMeta(jobId, meta);
 }
 /**
- * Read result.json. If it doesn't exist and waitMs is given, block via fs.watch
- * until result.json appears or the timeout elapses.
- *
- * Race safety: registers the watcher THEN re-stats. If result.json appeared
- * between the first stat and the watch registration, the re-stat catches it
- * before the watcher has a chance to miss it.
+ * Atomically write result.md (YAML frontmatter + markdown body) and update meta.json status.
+ * Used by `crtr job submit` for agent-driven markdown results.
+ */
+export function writeMarkdownResult(jobId, body, terminalStatus, reason) {
+    const dir = jobDir(jobId);
+    if (!existsSync(dir)) {
+        throw notFound(`job not found: ${jobId}`, { job_id: jobId });
+    }
+    const fm = {
+        status: terminalStatus,
+        written_at: new Date().toISOString(),
+    };
+    if (reason !== undefined && reason !== '') {
+        fm.reason = reason;
+    }
+    const content = `${renderFrontmatter(fm)}${body}`;
+    const tmp = join(dir, '.result.tmp');
+    writeFileSync(tmp, content, 'utf8');
+    renameSync(tmp, resultMdPath(jobId));
+    const meta = readMeta(jobId);
+    meta.status = terminalStatus;
+    writeMeta(jobId, meta);
+}
+/**
+ * Render a small fixed-shape frontmatter block. We control writer and reader,
+ * so a 3-key hand-rolled emitter is plenty — no YAML dep, no escaping surprises.
+ * Values are plain strings; we double-quote `reason` to survive newlines/colons.
  */
+function renderFrontmatter(fm) {
+    const lines = ['---', `status: ${fm.status}`, `written_at: ${fm.written_at}`];
+    if (fm.reason !== undefined) {
+        const escaped = fm.reason.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        lines.push(`reason: "${escaped}"`);
+    }
+    lines.push('---', '');
+    return lines.join('\n');
+}
+/**
+ * Parse the small fixed-shape frontmatter we emit. Tolerant of trailing
+ * whitespace; returns `{ frontmatter, body }`. Throws if the document does not
+ * start with `---\n` or no closing `---` is found.
+ */
+function parseMarkdownResult(raw) {
+    if (!raw.startsWith('---\n') && !raw.startsWith('---\r\n')) {
+        throw new Error('result.md missing opening --- delimiter');
+    }
+    const afterOpen = raw.indexOf('\n') + 1;
+    const closeIdx = raw.indexOf('\n---', afterOpen);
+    if (closeIdx === -1) {
+        throw new Error('result.md missing closing --- delimiter');
+    }
+    const fmBlock = raw.slice(afterOpen, closeIdx);
+    // Body starts after the closing `---` line.
+    const afterCloseLine = raw.indexOf('\n', closeIdx + 1);
+    const body = afterCloseLine === -1 ? '' : raw.slice(afterCloseLine + 1);
+    const fm = {};
+    for (const line of fmBlock.split('\n')) {
+        const m = line.match(/^([a-z_]+):\s*(.*)$/);
+        if (m === null)
+            continue;
+        const key = m[1];
+        if (m[2] === undefined)
+            continue;
+        let val = m[2];
+        if (val.startsWith('"') && val.endsWith('"') && val.length >= 2) {
+            val = val.slice(1, -1).replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+        }
+        if (key === 'status') {
+            fm.status = val;
+        }
+        else if (key === 'written_at') {
+            fm.written_at = val;
+        }
+        else if (key === 'reason') {
+            fm.reason = val;
+        }
+    }
+    if (fm.status === undefined || fm.written_at === undefined) {
+        throw new Error('result.md frontmatter missing status or written_at');
+    }
+    return { frontmatter: fm, body };
+}
 export function readResult(jobId, opts = {}) {
     const dir = jobDir(jobId);
     if (!existsSync(dir)) {
         throw notFound(`job not found: ${jobId}`, { job_id: jobId });
     }
-    function parseResult() {
-        const raw = readFileSync(resultPath(jobId), 'utf8');
+    function parseAt(path) {
+        const raw = readFileSync(path, 'utf8');
+        if (path.endsWith('.md')) {
+            const { frontmatter, body } = parseMarkdownResult(raw);
+            const out = { status: frontmatter.status, result_md: body };
+            if (frontmatter.reason !== undefined) {
+                out.reason = frontmatter.reason;
+            }
+            return out;
+        }
         const parsed = JSON.parse(raw);
         return { status: parsed.status, result: parsed.result };
     }
-    // Fast path: result already present.
-    if (existsSync(resultPath(jobId))) {
-        const r = parseResult();
-        return Promise.resolve({ status: r.status, result: r.result });
+    const existing = existingResultPath(jobId);
+    if (existing !== null) {
+        return Promise.resolve(parseAt(existing));
     }
     if (opts.waitMs === undefined || opts.waitMs <= 0) {
         return Promise.resolve({ status: 'timeout' });
     }
     return new Promise((resolve) => {
         let settled = false;
-        const finish = (status, result) => {
+        let timer;
+        let poll;
+        const finish = (response) => {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timer);
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (poll !== undefined)
+                clearInterval(poll);
             try {
                 watcher.close();
             }
             catch { /* noop */ }
-            resolve({ status, result });
+            resolve(response);
         };
-        // Register watcher first, then re-stat (race safety).
         const watcher = watch(dir, (_event, name) => {
-            if (name === 'result.json' && existsSync(resultPath(jobId))) {
-                const r = parseResult();
-                finish(r.status, r.result);
+            if (name !== 'result.md' && name !== 'result.json')
+                return;
+            const path = existingResultPath(jobId);
+            if (path !== null) {
+                finish(parseAt(path));
             }
         });
-        // Re-stat after watcher is registered to close the race window.
-        if (existsSync(resultPath(jobId))) {
-            const r = parseResult();
-            finish(r.status, r.result);
+        const path = existingResultPath(jobId);
+        if (path !== null) {
+            finish(parseAt(path));
             return;
         }
-        const timer = setTimeout(() => {
-            finish('timeout');
-        }, opts.waitMs);
+        // fs.watch only fires on result files. A pane that closes without a submit
+        // produces no such event, so poll to reap it instead of hanging until the
+        // full timeout budget elapses.
+        poll = setInterval(() => {
+            const found = existingResultPath(jobId);
+            if (found !== null) {
+                finish(parseAt(found));
+                return;
+            }
+            try {
+                if (reapIfPaneDead(readMeta(jobId))) {
+                    const reaped = existingResultPath(jobId);
+                    if (reaped !== null)
+                        finish(parseAt(reaped));
+                }
+            }
+            catch { /* noop */ }
+        }, PANE_POLL_MS);
+        // A non-finite budget (Infinity) means block until a result appears or the
+        // worker pane dies — used by `human review`, where the human may take an
+        // unbounded amount of time. The poll above still reaps a dead pane, so this
+        // never hangs forever on a closed pane.
+        if (Number.isFinite(opts.waitMs)) {
+            timer = setTimeout(() => {
+                finish({ status: 'timeout' });
+            }, opts.waitMs);
+        }
     });
 }
 /**
- * Derive job state from meta.json, result.json, and the tail of log.jsonl.
- * If a pid is recorded, is not alive, and no result.json exists → 'failed'.
+ * Derive job state from meta.json, the result file, and the tail of log.jsonl.
+ * If a pid is recorded, is not alive, and no result file exists → 'failed'.
  */
 export function jobStatus(jobId) {
-    const meta = readMeta(jobId);
+    let meta = readMeta(jobId);
+    if (reapIfPaneDead(meta)) {
+        meta = readMeta(jobId);
+    }
     const age_s = (Date.now() - new Date(meta.created_at).getTime()) / 1000;
-    // Derive effective state.
     let state = meta.status;
     if (state === 'live') {
-        if (existsSync(resultPath(jobId))) {
-            // result.json present but meta not yet updated (rare); trust the file.
+        const existing = existingResultPath(jobId);
+        if (existing !== null) {
+            // Result file present but meta not yet updated (rare); trust the file.
             try {
-                const r = JSON.parse(readFileSync(resultPath(jobId), 'utf8'));
-                state = r.status;
+                if (existing.endsWith('.md')) {
+                    const { frontmatter } = parseMarkdownResult(readFileSync(existing, 'utf8'));
+                    state = frontmatter.status;
+                }
+                else {
+                    const r = JSON.parse(readFileSync(existing, 'utf8'));
+                    state = r.status;
+                }
             }
             catch { /* leave as live */ }
         }
@@ -262,6 +461,8 @@ export function listJobs() {
         return [];
     const entries = readdirSync(root);
     const jobs = [];
+    // One tmux query, reused to reap every job whose pane has vanished.
+    const panes = allTmuxPaneIds();
     for (const entry of entries) {
         const dir = join(root, entry);
         try {
@@ -270,13 +471,24 @@ export function listJobs() {
             const mp = join(dir, 'meta.json');
             if (!existsSync(mp))
                 continue;
-            const meta = JSON.parse(readFileSync(mp, 'utf8'));
-            // Derive effective state (result.json beats meta.status for live jobs).
+            let meta = JSON.parse(readFileSync(mp, 'utf8'));
+            if (reapIfPaneDead(meta, panes)) {
+                meta = JSON.parse(readFileSync(mp, 'utf8'));
+            }
+            // Derive effective state (result file beats meta.status for live jobs).
             let state = meta.status;
-            if (state === 'live' && existsSync(join(dir, 'result.json'))) {
+            if (state === 'live') {
+                const mdP = join(dir, 'result.md');
+                const jsP = join(dir, 'result.json');
                 try {
-                    const r = JSON.parse(readFileSync(join(dir, 'result.json'), 'utf8'));
-                    state = r.status;
+                    if (existsSync(mdP)) {
+                        const { frontmatter } = parseMarkdownResult(readFileSync(mdP, 'utf8'));
+                        state = frontmatter.status;
+                    }
+                    else if (existsSync(jsP)) {
+                        const r = JSON.parse(readFileSync(jsP, 'utf8'));
+                        state = r.status;
+                    }
                 }
                 catch { /* leave as live */ }
             }

package/dist/core/resolver.d.ts

@@ -22,8 +22,7 @@ export interface SkillResolutionOpts {
 export declare function resolveSkill(rawName: string, opts?: SkillResolutionOpts): Skill;
 export interface ParsedSkillQualifier {
     scope?: Scope;
-    plugin?: string;
-    name: string;
+    segments: string[];
 }
 export declare function parseSkillQualifier(raw: string): ParsedSkillQualifier;
 export declare function listInstalledMarketplaces(scope: Scope): InstalledMarketplace[];