agentera 3.0.0-dev.7 → 3.0.0-dev.74

package/dist/cli/commands/state/get.js

@@ -0,0 +1,129 @@
+import YAML from "yaml";
+import { resolveSourceRoot } from "../../../core/sourceRoot.js";
+import { StateRetrievalFailure } from "../../../state/directRetrieval.js";
+import { getDecisionEntity } from "../../../state/decisionEntities.js";
+import { getHealthEntity } from "../../../state/healthEntities.js";
+import { getObjectiveEntity } from "../../../state/objectiveExperimentEntities.js";
+import { getProgressEntity } from "../../../state/progressEntities.js";
+import { getTodoDocsEntity } from "../../../state/todoDocsEntities.js";
+import { emitStructured } from "../../structured.js";
+import { entityListFamily } from "../../../state/entityRetrievalHelp.js";
+import { runtimeGenericEntityListFamily } from "../../../state/entityListRuntimeRegistry.js";
+function requestedFormat(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--format") {
+            const value = argv[index + 1];
+            if (value === "json" || value === "yaml")
+                return value;
+        }
+        if (token.startsWith("--format=")) {
+            const value = token.slice("--format=".length);
+            if (value === "json" || value === "yaml")
+                return value;
+        }
+    }
+    return "text";
+}
+function failure(message, id, artifact = "progress") {
+    const runtime = runtimeGenericEntityListFamily(artifact);
+    const family = runtime ? entityListFamily(runtime.key) : undefined;
+    return new StateRetrievalFailure({
+        schemaVersion: "agentera.stateFailure.v1",
+        status: "fail",
+        error: {
+            class: "invalid_request",
+            message,
+            syntax: family?.get ?? `agentera state ${artifact} get --id ID --format json`,
+            example: `agentera state ${artifact} get --id ${id ?? "qjtrmnpvka"} --format json`,
+            recovery: `Use a bare ten-letter ${artifact} ID returned by append or list; no state was changed.`,
+            artifact,
+            ...(id ? { id } : {}),
+        },
+    }, 2);
+}
+function readValue(argv, index, name) {
+    const token = argv[index];
+    if (token.startsWith(`${name}=`))
+        return { value: token.slice(name.length + 1), next: index + 1 };
+    const value = argv[index + 1];
+    if (!value || value.startsWith("--"))
+        throw new Error(`${name} requires a value`);
+    return { value, next: index + 2 };
+}
+function emitFailure(error, format, io) {
+    if (format === "json" || format === "yaml") {
+        emitStructured(error.body, format, io.out ?? ((text) => process.stdout.write(text)));
+    }
+    else {
+        const detail = error.body.error;
+        (io.err ?? ((text) => process.stderr.write(text)))([
+            `Error: ${detail.message}`,
+            `Syntax: ${detail.syntax}`,
+            `Example: ${detail.example}`,
+            `Recovery: ${detail.recovery}`,
+        ].join("\n") + "\n");
+    }
+    return error.exitCode;
+}
+export function runStateGet(artifactId, argv, io, projectRoot = process.cwd()) {
+    const format = requestedFormat(argv);
+    const sourceRoot = resolveSourceRoot();
+    try {
+        if (!runtimeGenericEntityListFamily(artifactId))
+            throw failure(`unsupported state artifact '${artifactId}'`, undefined, artifactId);
+        let id;
+        let entityFormat = "text";
+        let formatSupplied = false;
+        for (let index = 0; index < argv.length;) {
+            const token = argv[index];
+            if (token !== "--id" && !token.startsWith("--id=") && token !== "--format" && !token.startsWith("--format=")) {
+                throw failure(`unrecognized argument '${token}'; entity-mode ${artifactId} retrieval requires --id ID`, id, artifactId);
+            }
+            const name = token.startsWith("--id") ? "--id" : "--format";
+            let parsed;
+            try {
+                parsed = readValue(argv, index, name);
+            }
+            catch (error) {
+                throw failure(error.message, id, artifactId);
+            }
+            index = parsed.next;
+            if (name === "--id") {
+                if (id !== undefined)
+                    throw failure("--id may only be supplied once", id, artifactId);
+                id = parsed.value;
+            }
+            else {
+                if (formatSupplied)
+                    throw failure("--format may only be supplied once", id, artifactId);
+                formatSupplied = true;
+                if (parsed.value !== "text" && parsed.value !== "json" && parsed.value !== "yaml")
+                    throw failure(`invalid --format '${parsed.value}'`, id, artifactId);
+                entityFormat = parsed.value;
+            }
+        }
+        if (!id)
+            throw failure(`--id is required for entity-mode ${artifactId} retrieval`, id, artifactId);
+        const response = artifactId === "progress"
+            ? getProgressEntity(projectRoot, id, sourceRoot)
+            : artifactId === "decisions"
+                ? getDecisionEntity(projectRoot, id, sourceRoot)
+                : artifactId === "health"
+                    ? getHealthEntity(projectRoot, id, sourceRoot)
+                    : artifactId === "objective"
+                        ? getObjectiveEntity(projectRoot, id, sourceRoot)
+                        : getTodoDocsEntity(projectRoot, artifactId, id, sourceRoot);
+        const output = io.out ?? ((text) => process.stdout.write(text));
+        if (entityFormat === "json" || entityFormat === "yaml")
+            emitStructured(response, entityFormat, output);
+        else
+            output(YAML.stringify(response));
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof StateRetrievalFailure)
+            return emitFailure(error, format, io);
+        return emitFailure(failure(error.message, undefined, artifactId), format, io);
+    }
+}

package/dist/cli/commands/state/health.js

@@ -1,116 +1,14 @@
-/**
- * `state health` query (HEALTH.md / health.yaml audits).
- *
- * Surfaces the latest health audit by `number`, optionally filtered
- * by dimension (a grade key or a dimensions_detail.name substring).
- */
-import { asList, emitStateStructured, extractEntries, loadArtifact, missingSchemaError, sourceMetadata, structuredState, } from "../../stateQuery.js";
-import { artifactPath } from "../../appContext.js";
-import { out, err } from "./shared.js";
-export function healthAuditNumber(entry) {
-    const number = entry.number;
-    if (typeof number === "number" && Number.isInteger(number))
-        return number;
-    if (typeof number === "string" && /^\d+$/.test(number))
-        return parseInt(number, 10);
-    return null;
-}
-export function latestHealthAudit(entries) {
-    if (entries.length === 0)
-        return null;
-    let best = null;
-    let bestNumber = -1;
-    for (const entry of entries) {
-        const number = healthAuditNumber(entry);
-        if (number === null)
-            continue;
-        if (number > bestNumber) {
-            bestNumber = number;
-            best = entry;
-        }
-    }
-    return best !== null ? best : entries[entries.length - 1];
-}
-export function queryHealth(args, schemas, io) {
-    const o = out(io);
-    const e = err(io);
-    const info = schemas.health;
-    if (!info) {
-        e(missingSchemaError("health") + "\n");
-        return 1;
-    }
-    const p = artifactPath(info, "health");
-    const data = loadArtifact(p);
-    const entries = extractEntries(data);
-    const dimension = args.dimension ?? null;
-    let latest = latestHealthAudit(entries);
-    let latestEntries = latest ? [latest] : [];
-    if (dimension && latestEntries.length > 0) {
-        latest = latestEntries[0];
-        const dimLower = dimension.toLowerCase();
-        let matched = false;
-        const grades = latest.grades;
-        if (grades && typeof grades === "object" && !Array.isArray(grades)) {
-            matched = Object.keys(grades).some((gk) => String(gk).toLowerCase().includes(dimLower));
-        }
-        const details = latest.dimensions_detail;
-        if (Array.isArray(details)) {
-            matched =
-                matched ||
-                    details.some((d) => d && typeof d === "object" && !Array.isArray(d) && String(d.name ?? "").toLowerCase().includes(dimLower));
-        }
-        if (!matched)
-            latestEntries = [];
-    }
+import { emitStructured } from "../../structured.js";
+import { listHealthEntities } from "../../../state/healthEntities.js";
+import YAML from "yaml";
+import { out } from "./shared.js";
+export function queryHealth(args, _schemas, io) {
     const format = args.format ?? "text";
-    if (format !== "text") {
-        return emitStateStructured("health", structuredState("health", latestEntries, sourceMetadata("health", p), {
-            filters: { dimension },
-            summary: { latest_only: true },
-        }), format, args.fields, o, e);
-    }
-    if (entries.length === 0)
-        return 0;
-    latest = latestHealthAudit(entries);
-    if (!latest)
-        return 0;
-    if (dimension) {
-        const dimLower = dimension.toLowerCase();
-        // cast: latest.grades is read from a parsed health.yaml audit entry (IO boundary)
-        const grades = (latest.grades ?? {});
-        let matched = false;
-        for (const [gk, gv] of Object.entries(grades)) {
-            if (String(gk).toLowerCase().includes(dimLower)) {
-                o(`${gk}: ${gv}\n`);
-                matched = true;
-            }
-        }
-        const details = asList(latest.dimensions_detail);
-        for (const d of details) {
-            const dn = String(d.name ?? "");
-            if (dn.toLowerCase().includes(dimLower)) {
-                const summary = d.summary ?? "";
-                if (summary)
-                    o(`  ${summary}\n`);
-                for (const f of asList(d.findings)) {
-                    o(`  [${f.severity ?? ""}] ${f.heading ?? ""}\n`);
-                }
-                matched = true;
-            }
-        }
-        if (!matched)
-            return 0;
-    }
-    else {
-        const num = latest.number ?? "?";
-        const traj = latest.trajectory ?? "";
-        o(`Audit ${num}: ${traj}\n`);
-        // cast: latest.grades is read from a parsed health.yaml audit entry (IO boundary)
-        const grades = (latest.grades ?? {});
-        for (const [gk, gv] of Object.entries(grades)) {
-            o(`  ${gk}: ${gv}\n`);
-        }
-    }
+    const response = listHealthEntities(process.cwd(), args.limit ?? 1, args.dimension ?? undefined, args.cursor ?? undefined, { format });
+    const output = out(io);
+    if (format === "text")
+        output(YAML.stringify(response));
+    else
+        emitStructured(response, format, output);
     return 0;
 }
-//# sourceMappingURL=health.js.map

package/dist/cli/commands/state/index.js

@@ -1,51 +1,16 @@
 /**
  * Public surface for the `state <name>` command family.
  *
- * The `cmdState` entry point validates the incoming args, loads the
- * schema directory, and dispatches to the per-state-family handler
- * in `STATE_COMMAND_HANDLERS`. The `isPortedStateCommand` predicate
- * is the public surface used by `cli/dispatch.ts` to decide whether
- * a top-level token is a state command or a deprecated alias.
+ * Record-family retrieval dispatch is owned by entityListRuntimeRegistry.
+ * This module retains the specialized projections used by startup collectors
+ * and compatibility code; it does not enumerate public retrieval routes.
  */
-import { COMMAND_FILTERS, validateFilterValues } from "../../stateQuery.js";
-import { loadSchemas, discoverSchemasDir } from "../../appContext.js";
-import { err } from "./shared.js";
 import { queryProgress } from "./progress.js";
 import { queryPlan } from "./plan.js";
-import { queryHealth, healthAuditNumber, latestHealthAudit } from "./health.js";
+import { queryHealth } from "./health.js";
 import { queryDocs } from "./docs.js";
 import { queryObjective } from "./objective.js";
 import { queryExperiments } from "./experiments.js";
 import { queryTodo, normalizeSeverity } from "./todo.js";
-import { queryDecisions, decisionContextEntry, decisionSatisfactionContext, decisionSourceContract, extractDecisionEntries, displayFields, } from "./decisions.js";
-export { queryProgress, queryPlan, queryHealth, queryDocs, queryObjective, queryExperiments, queryTodo, queryDecisions, healthAuditNumber, latestHealthAudit, normalizeSeverity, decisionContextEntry, decisionSatisfactionContext, decisionSourceContract, extractDecisionEntries, displayFields, };
-const STATE_COMMAND_HANDLERS = {
-    progress: queryProgress,
-    plan: queryPlan,
-    health: queryHealth,
-    docs: queryDocs,
-    objective: queryObjective,
-    experiments: queryExperiments,
-    todo: queryTodo,
-    decisions: queryDecisions,
-};
-export function isPortedStateCommand(command) {
-    return command in STATE_COMMAND_HANDLERS;
-}
-export function cmdState(args, io) {
-    const e = err(io);
-    try {
-        validateFilterValues(args, COMMAND_FILTERS[args.command] ?? []);
-        if (args.limit !== null && args.limit !== undefined && args.limit < 0) {
-            throw new Error("limit must be zero or greater");
-        }
-        const schemas = loadSchemas(discoverSchemasDir());
-        const handler = STATE_COMMAND_HANDLERS[args.command];
-        return handler(args, schemas, io);
-    }
-    catch (exc) {
-        e(`Error: ${exc.message}\n`);
-        return 2;
-    }
-}
-//# sourceMappingURL=index.js.map
+import { queryDecisions, decisionContextEntry, decisionSatisfactionContext, decisionSourceContract, extractDecisionEntries, hydrateDecisionEntries, displayFields, } from "./decisions.js";
+export { queryProgress, queryPlan, queryHealth, queryDocs, queryObjective, queryExperiments, queryTodo, queryDecisions, normalizeSeverity, decisionContextEntry, decisionSatisfactionContext, decisionSourceContract, extractDecisionEntries, hydrateDecisionEntries, displayFields, };

package/dist/cli/commands/state/list.js

@@ -0,0 +1,194 @@
+import { resolveSourceRoot } from "../../../core/sourceRoot.js";
+import { StateRetrievalFailure } from "../../../state/directRetrieval.js";
+import { emitStructured } from "../../structured.js";
+import { listProgressEntities, renderProgressEntityListText } from "../../../state/progressEntities.js";
+import { listDecisionEntities } from "../../../state/decisionEntities.js";
+import { listHealthEntities } from "../../../state/healthEntities.js";
+import { listObjectiveEntities } from "../../../state/objectiveExperimentEntities.js";
+import { listTodoDocsEntities } from "../../../state/todoDocsEntities.js";
+import YAML from "yaml";
+import { entityListFamilies, entityListValidValues } from "../../../state/entityRetrievalHelp.js";
+import { ENTITY_LIST_RUNTIME_FAMILIES, runtimeGenericEntityListFamily } from "../../../state/entityListRuntimeRegistry.js";
+function requestedFormat(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--format") {
+            const value = argv[index + 1];
+            if (value === "json" || value === "yaml")
+                return value;
+        }
+        if (token.startsWith("--format=")) {
+            const value = token.slice("--format=".length);
+            if (value === "json" || value === "yaml")
+                return value;
+        }
+    }
+    return "text";
+}
+function syntax(artifactId) {
+    return `agentera state ${artifactId} list [--limit N] [--cursor TOKEN] --format json`;
+}
+function failure(className, artifactId, message, example = `agentera state ${artifactId} list --limit 20 --format json`, validValues) {
+    const family = entityListFamilies().find(({ key }) => key === artifactId);
+    return new StateRetrievalFailure({
+        schemaVersion: "agentera.stateFailure.v1",
+        status: "fail",
+        error: {
+            class: className,
+            message,
+            syntax: family?.syntax ?? syntax(artifactId),
+            example: family?.example ?? example,
+            recovery: family ? `Run \`${family.example}\`; no state was changed.` : "Correct the command using the valid syntax and retry; no state was changed.",
+            artifact_id: artifactId,
+            ...(validValues ? { valid_values: validValues } : family ? { valid_values: entityListValidValues(family) } : {}),
+        },
+    }, 2);
+}
+function readValue(argv, index, name) {
+    const token = argv[index];
+    if (token.startsWith(`${name}=`))
+        return { value: token.slice(name.length + 1), next: index + 1 };
+    const value = argv[index + 1];
+    if (!value || value.startsWith("--"))
+        throw new Error(`${name} requires a value`);
+    return { value, next: index + 2 };
+}
+function parseListArgs(artifactId, argv) {
+    const runtime = runtimeGenericEntityListFamily(artifactId);
+    if (!runtime) {
+        const validValues = ENTITY_LIST_RUNTIME_FAMILIES.map(({ commandTokens }) => commandTokens.join(" "));
+        throw failure("unsupported_artifact", artifactId, `unsupported state artifact '${artifactId}'`, undefined, validValues);
+    }
+    const family = entityListFamilies().find(({ key }) => key === runtime.key);
+    let limit = family.bounds.default;
+    let cursor;
+    let format = "text";
+    const filters = {};
+    const selector = {};
+    const allowedFilters = new Set(family.filters.map(({ name }) => `--${name}`));
+    let limitSupplied = false;
+    let cursorSupplied = false;
+    let formatSupplied = false;
+    const filterSupplied = new Set();
+    for (let index = 0; index < argv.length;) {
+        const token = argv[index];
+        if (token === "--ids-only") {
+            if (selector.idsOnly)
+                throw failure("invalid_request", artifactId, "--ids-only may only be supplied once");
+            selector.idsOnly = true;
+            index += 1;
+            continue;
+        }
+        const matches = (flag) => token === flag || token.startsWith(`${flag}=`);
+        const name = matches("--limit") ? "--limit" : matches("--cursor") ? "--cursor" : matches("--format") ? "--format" : matches("--fields") ? "--fields" : [...allowedFilters].find(matches) ?? null;
+        if (!name)
+            throw failure("invalid_request", artifactId, `unrecognized argument '${token}'`);
+        let parsed;
+        try {
+            parsed = readValue(argv, index, name);
+        }
+        catch (error) {
+            throw failure("invalid_request", artifactId, error.message);
+        }
+        index = parsed.next;
+        if (name === "--limit") {
+            if (limitSupplied)
+                throw failure("invalid_request", artifactId, "--limit may only be supplied once");
+            limitSupplied = true;
+            if (!/^[1-9][0-9]*$/.test(parsed.value))
+                throw failure("invalid_request", artifactId, `argument --limit must be a positive canonical integer from ${family.bounds.minimum} through ${family.bounds.maximum}`);
+            limit = Number(parsed.value);
+            if (!Number.isSafeInteger(limit) || limit < family.bounds.minimum || limit > family.bounds.maximum)
+                throw failure("invalid_request", artifactId, `argument --limit must be between ${family.bounds.minimum} and ${family.bounds.maximum}`);
+        }
+        else if (name === "--cursor") {
+            if (cursorSupplied)
+                throw failure("invalid_request", artifactId, "--cursor may only be supplied once");
+            cursorSupplied = true;
+            if (parsed.value.length === 0)
+                throw failure("invalid_request", artifactId, "argument --cursor must be a non-empty opaque token");
+            cursor = parsed.value;
+        }
+        else if (name === "--fields") {
+            if (selector.fields !== undefined)
+                throw failure("invalid_request", artifactId, "--fields may only be supplied once");
+            selector.fields = parsed.value;
+        }
+        else {
+            if (name !== "--format") {
+                if (filterSupplied.has(name))
+                    throw failure("invalid_request", artifactId, `${name} may only be supplied once`);
+                filterSupplied.add(name);
+                const key = name.slice(2);
+                filters[key] = parsed.value;
+                continue;
+            }
+            if (formatSupplied)
+                throw failure("invalid_request", artifactId, "--format may only be supplied once");
+            formatSupplied = true;
+            if (!family.formats.includes(parsed.value)) {
+                throw failure("invalid_request", artifactId, `argument --format: invalid choice: '${parsed.value}' (choose from ${family.formats.map((value) => `'${value}'`).join(", ")})`);
+            }
+            format = parsed.value;
+        }
+    }
+    return { limit, ...(cursor ? { cursor } : {}), format, filters, selector };
+}
+function emitFailure(error, format, io) {
+    const out = io.out ?? ((text) => process.stdout.write(text));
+    if (format === "json" || format === "yaml")
+        emitStructured(error.body, format, out);
+    else {
+        const details = error.body.error;
+        (io.err ?? ((text) => process.stderr.write(text)))([
+            `Error: ${details.message}`,
+            `Class: ${details.class}`,
+            `Syntax: ${details.syntax}`,
+            `Valid values: ${(details.valid_values ?? []).join("; ")}`,
+            `Example: ${details.example}`,
+            `Recovery: ${details.recovery}`,
+        ].join("\n") + "\n");
+    }
+    return error.exitCode;
+}
+export function runStateList(artifactId, argv, io, projectRoot = process.cwd()) {
+    const format = requestedFormat(argv);
+    const sourceRoot = resolveSourceRoot();
+    try {
+        const args = parseListArgs(artifactId, argv);
+        const response = artifactId === "progress"
+            ? listProgressEntities(projectRoot, args.limit, args.filters, args.cursor, { sourceRoot, format: args.format, selector: args.selector })
+            : artifactId === "decisions"
+                ? listDecisionEntities(projectRoot, args.limit, args.filters.topic ?? undefined, args.cursor, { sourceRoot, format: args.format, selector: args.selector })
+                : artifactId === "health"
+                    ? listHealthEntities(projectRoot, args.limit, args.filters.dimension ?? undefined, args.cursor, { sourceRoot, format: args.format, selector: args.selector })
+                    : artifactId === "objective"
+                        ? listObjectiveEntities(projectRoot, args.limit, args.cursor, { sourceRoot, format: args.format, selector: args.selector })
+                        : listTodoDocsEntities(projectRoot, artifactId, args.limit, args.cursor, args.filters, { sourceRoot, format: args.format, selector: args.selector });
+        const output = io.out ?? ((text) => process.stdout.write(text));
+        if (args.format === "text")
+            output(artifactId === "progress" ? renderProgressEntityListText(response) : YAML.stringify(response));
+        else
+            emitStructured(response, args.format, output);
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof StateRetrievalFailure) {
+            const body = structuredClone(error.body);
+            delete body.error.artifact_id;
+            body.error.artifact = artifactId;
+            return emitFailure(new StateRetrievalFailure(body, error.exitCode), format, io);
+        }
+        return emitFailure(new StateRetrievalFailure({
+            schemaVersion: "agentera.stateFailure.v1",
+            status: "fail",
+            error: {
+                class: "unsupported_state",
+                message: error.message,
+                syntax: syntax(artifactId),
+                example: `agentera state ${artifactId} list --limit 20 --format json`,
+                recovery: "Use a state format supported by the storage authority, then retry.",
+            },
+        }, 1), format, io);
+    }
+}

package/dist/cli/commands/state/objective.js

@@ -1,69 +1,25 @@
-/**
- * `state objective` query (OBJECTIVE.md / objective.yaml).
- *
- * Reports the single current objective plus its closure block (when
- * status is "closed"), with the same envelope shape used by prime.
- */
-import { asList, emitStateStructured, filterByFieldValue, formatEntry, loadArtifact, missingSchemaError, sourceMetadata, structuredState, truncate, } from "../../stateQuery.js";
-import { artifactPath } from "../../appContext.js";
-import { firstPresent } from "../../stateQuery.js";
-import { out, err } from "./shared.js";
-export function queryObjective(args, schemas, io) {
-    const o = out(io);
-    const e = err(io);
-    const info = schemas.objective;
-    if (!info) {
-        e(missingSchemaError("objective") + "\n");
-        return 1;
-    }
-    const p = artifactPath(info, "objective");
-    const data = loadArtifact(p);
-    const format = args.format ?? "text";
-    const isDict = data !== null && typeof data === "object" && !Array.isArray(data);
-    if (!isDict) {
-        if (format !== "text") {
-            return emitStateStructured("objective", structuredState("objective", [], sourceMetadata("objective", p), { filters: { status: args.status ?? null } }), format, args.fields, o, e);
-        }
-        return 0;
-    }
-    // cast: data is the parsed objective artifact from loadArtifact (YAML/MD IO boundary)
-    const d = data;
-    const legacyEntries = asList(d.entries);
-    if (legacyEntries.length > 0) {
-        let entries = legacyEntries;
-        const statusFilter = args.status ?? null;
-        if (statusFilter)
-            entries = filterByFieldValue(entries, "status", statusFilter);
-        if (format !== "text") {
-            return emitStateStructured("objective", structuredState("objective", entries, sourceMetadata("objective", p), { filters: { status: statusFilter } }), format, args.fields, o, e);
-        }
-        for (const entry of entries) {
-            const line = formatEntry(entry, ["title", "status", "target", "reason"]);
-            if (line)
-                o(line + "\n");
-        }
+import { StateRetrievalFailure } from "../../../state/directRetrieval.js";
+import { currentObjectiveEntity } from "../../../state/objectiveExperimentEntities.js";
+import { emitStructured } from "../../structured.js";
+import { formatEntry } from "../../stateQuery.js";
+import { err, out } from "./shared.js";
+export function queryObjective(args, _schemas, io) {
+    const output = out(io);
+    try {
+        const response = currentObjectiveEntity(process.cwd());
+        if (args.format === "json" || args.format === "yaml")
+            emitStructured(response, args.format, output);
+        else
+            output(formatEntry(response.entries[0], ["id", "artifact"]) + "\n");
         return 0;
     }
-    const header = d.header && typeof d.header === "object" && !Array.isArray(d.header) ? d.header : {};
-    const objective = d.objective && typeof d.objective === "object" && !Array.isArray(d.objective) ? d.objective : d;
-    const title = firstPresent(header, ["title"], objective.title ?? "");
-    const status = firstPresent(header, ["status"], objective.status ?? "");
-    const closure = d.closure && typeof d.closure === "object" && !Array.isArray(d.closure) ? d.closure : {};
-    if (format !== "text") {
-        return emitStateStructured("objective", structuredState("objective", objective ? [objective] : [], sourceMetadata("objective", p), {
-            filters: { status: args.status ?? null },
-            summary: { title, status, header, closure },
-        }), format, args.fields, o, e);
-    }
-    o(`Objective: title=${truncate(title)} | status=${status || "unknown"}\n`);
-    for (const key of ["description", "target", "measurement", "direction", "unit"]) {
-        const value = objective[key] ?? d[key];
-        if (value)
-            o(`${key}: ${truncate(value)}\n`);
-    }
-    if (Object.keys(closure).length > 0) {
-        o(formatEntry(closure, ["final_value", "target", "reason"]) + "\n");
+    catch (error) {
+        if (!(error instanceof StateRetrievalFailure))
+            throw error;
+        if (args.format === "json" || args.format === "yaml")
+            emitStructured(error.body, args.format, output);
+        else
+            err(io)(`Error: ${error.body.error.message}\nRecovery: ${error.body.error.recovery}\n`);
+        return error.exitCode;
     }
-    return 0;
 }
-//# sourceMappingURL=objective.js.map