mdkg 0.1.4 → 0.1.6

package/dist/commands/goal.js

@@ -0,0 +1,548 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGoalShowCommand = runGoalShowCommand;
+exports.runGoalEvaluateCommand = runGoalEvaluateCommand;
+exports.runGoalNextCommand = runGoalNextCommand;
+exports.runGoalSelectCommand = runGoalSelectCommand;
+exports.runGoalCurrentCommand = runGoalCurrentCommand;
+exports.runGoalClearCommand = runGoalClearCommand;
+exports.runGoalClaimCommand = runGoalClaimCommand;
+exports.runGoalPauseCommand = runGoalPauseCommand;
+exports.runGoalResumeCommand = runGoalResumeCommand;
+exports.runGoalDoneCommand = runGoalDoneCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../core/config");
+const goal_scope_1 = require("../graph/goal_scope");
+const index_cache_1 = require("../graph/index_cache");
+const frontmatter_1 = require("../graph/frontmatter");
+const indexer_1 = require("../graph/indexer");
+const reindex_1 = require("../graph/reindex");
+const atomic_1 = require("../util/atomic");
+const date_1 = require("../util/date");
+const errors_1 = require("../util/errors");
+const lock_1 = require("../util/lock");
+const qid_1 = require("../util/qid");
+const sort_1 = require("../util/sort");
+const event_support_1 = require("./event_support");
+const node_card_1 = require("./node_card");
+const CONCRETE_GOAL_NEXT_TYPES = new Set(["feat", "task", "bug", "test"]);
+const SELECTED_GOAL_STATE_PATH = path_1.default.join(".mdkg", "state", "selected-goal.json");
+const GOAL_STATE_BY_ACTION = {
+    pause: "paused",
+    resume: "active",
+    done: "achieved",
+};
+const STATUS_BY_ACTION = {
+    pause: "blocked",
+    resume: "progress",
+    done: "done",
+};
+function normalizeWorkspace(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (normalized === "all") {
+        throw new errors_1.UsageError("--ws all is not valid here");
+    }
+    return normalized;
+}
+function toStringList(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item));
+    }
+    return [];
+}
+function selectedGoalPath(root) {
+    return path_1.default.join(root, SELECTED_GOAL_STATE_PATH);
+}
+function readSelectedGoalState(root, warnings) {
+    const filePath = selectedGoalPath(root);
+    if (!fs_1.default.existsSync(filePath)) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(fs_1.default.readFileSync(filePath, "utf8"));
+        if (typeof parsed.qid === "string" &&
+            typeof parsed.id === "string" &&
+            typeof parsed.ws === "string" &&
+            typeof parsed.selected_at === "string") {
+            return {
+                qid: parsed.qid.toLowerCase(),
+                id: parsed.id.toLowerCase(),
+                ws: parsed.ws.toLowerCase(),
+                selected_at: parsed.selected_at,
+            };
+        }
+        warnings.push("selected goal state is malformed; run `mdkg goal select <goal-id>`");
+        return undefined;
+    }
+    catch {
+        warnings.push("selected goal state is unreadable; run `mdkg goal select <goal-id>`");
+        return undefined;
+    }
+}
+function writeSelectedGoalState(root, node, now) {
+    const state = {
+        qid: node.qid,
+        id: node.id,
+        ws: node.ws,
+        selected_at: now.toISOString(),
+    };
+    (0, atomic_1.atomicWriteFile)(selectedGoalPath(root), `${JSON.stringify(state, null, 2)}\n`);
+}
+function removeSelectedGoalState(root) {
+    const filePath = selectedGoalPath(root);
+    if (!fs_1.default.existsSync(filePath)) {
+        return false;
+    }
+    fs_1.default.rmSync(filePath, { force: true });
+    return true;
+}
+function optionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function resolveExplicitGoal(index, idOrQid, wsHint) {
+    const resolved = (0, qid_1.resolveQid)(index, idOrQid, wsHint);
+    if (resolved.status !== "ok") {
+        throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("goal", idOrQid, resolved, wsHint));
+    }
+    const node = index.nodes[resolved.qid];
+    if (!node) {
+        throw new errors_1.NotFoundError(`goal not found: ${idOrQid}`);
+    }
+    return node;
+}
+function activeGoalCandidates(index, wsHint) {
+    return Object.values(index.nodes)
+        .filter((node) => node.type === "goal")
+        .filter((node) => !node.source?.imported)
+        .filter((node) => (wsHint ? node.ws === wsHint : true))
+        .filter((node) => node.status === "progress" && node.attributes.goal_state === "active")
+        .sort((a, b) => a.qid.localeCompare(b.qid));
+}
+function resolveGoalSelection(root, index, idOrQid, wsHint) {
+    const warnings = [];
+    if (idOrQid) {
+        return {
+            node: resolveExplicitGoal(index, idOrQid, wsHint),
+            source: "explicit",
+            warnings,
+        };
+    }
+    const selected = readSelectedGoalState(root, warnings);
+    if (selected) {
+        const node = index.nodes[selected.qid];
+        if (node && node.type === "goal" && !node.source?.imported) {
+            return { node, source: "selected", warnings };
+        }
+        warnings.push(`selected goal ${selected.qid} is not available; run \`mdkg goal select <goal-id>\``);
+    }
+    const active = activeGoalCandidates(index, wsHint);
+    if (active.length === 1) {
+        return { node: active[0], source: "unique_active", warnings };
+    }
+    if (active.length > 1) {
+        throw new errors_1.UsageError(`multiple active goals found: ${active.map((node) => node.qid).join(", ")}; run \`mdkg goal select <goal-id>\``);
+    }
+    throw new errors_1.NotFoundError("no selected goal or unique active goal found; run `mdkg goal select <goal-id>`");
+}
+function loadGoal(root, idOrQid, wsHint) {
+    const config = (0, config_1.loadConfig)(root);
+    const { index } = (0, index_cache_1.loadIndex)({ root, config });
+    const ws = normalizeWorkspace(wsHint);
+    const selection = resolveGoalSelection(root, index, idOrQid, ws);
+    const node = selection.node;
+    if (node.source?.imported) {
+        throw new errors_1.UsageError(`cannot mutate read-only subgraph node ${node.qid}; update the source workspace for subgraph ${node.source.subgraph_alias}`);
+    }
+    if (node.type !== "goal") {
+        throw new errors_1.UsageError(`mdkg goal requires a goal node; got ${node.type}:${node.id}`);
+    }
+    const filePath = path_1.default.resolve(root, node.path);
+    const content = fs_1.default.readFileSync(filePath, "utf8");
+    const parsed = (0, frontmatter_1.parseFrontmatter)(content, filePath);
+    return {
+        config,
+        index,
+        node,
+        filePath,
+        frontmatter: { ...parsed.frontmatter },
+        body: parsed.body,
+        resolutionSource: selection.source,
+        warnings: selection.warnings,
+    };
+}
+function goalReceipt(root, loaded) {
+    const fm = loaded.frontmatter;
+    const rawPriority = fm.priority;
+    const priority = rawPriority === undefined ? undefined : Number.parseInt(String(rawPriority), 10);
+    return {
+        workspace: loaded.node.ws,
+        id: loaded.node.id,
+        qid: loaded.node.qid,
+        path: path_1.default.relative(root, loaded.filePath),
+        type: loaded.node.type,
+        title: loaded.node.title,
+        status: String(fm.status ?? ""),
+        ...(Number.isInteger(priority) ? { priority } : {}),
+        goal_state: String(fm.goal_state ?? ""),
+        goal_condition: String(fm.goal_condition ?? ""),
+        scope_refs: toStringList(fm.scope_refs),
+        active_node: optionalString(fm.active_node),
+        required_skills: toStringList(fm.required_skills),
+        required_checks: toStringList(fm.required_checks),
+        max_iterations: optionalString(fm.max_iterations),
+        blocked_after_attempts: optionalString(fm.blocked_after_attempts),
+    };
+}
+function writeGoalFile(loaded, now) {
+    loaded.frontmatter.updated = (0, date_1.formatDate)(now);
+    const lines = (0, frontmatter_1.formatFrontmatter)(loaded.frontmatter, frontmatter_1.DEFAULT_FRONTMATTER_KEY_ORDER);
+    const frontmatterBlock = ["---", ...lines, "---"].join("\n");
+    const content = loaded.body.length > 0 ? `${frontmatterBlock}\n${loaded.body}` : frontmatterBlock;
+    (0, atomic_1.atomicWriteFile)(loaded.filePath, content);
+}
+function maybeReindex(root, config) {
+    if (!config.index.auto_reindex) {
+        return;
+    }
+    (0, reindex_1.writeDerivedIndexes)(root, config, (0, indexer_1.buildIndex)(root, config, { tolerant: config.index.tolerant }));
+}
+function ensureStatusAllowed(config, status) {
+    const normalized = status.toLowerCase();
+    const allowed = new Set(config.work.status_enum.map((value) => value.toLowerCase()));
+    if (!allowed.has(normalized)) {
+        throw new errors_1.UsageError(`goal status ${normalized} is not allowed by work.status_enum`);
+    }
+    return normalized;
+}
+function completionEvidenceBody(body) {
+    const match = body.match(/(^|\n)# Completion Evidence\s*\n([\s\S]*?)(?=\n# |\s*$)/i);
+    return (match?.[2] ?? "").trim();
+}
+function hasCompletionEvidence(body) {
+    const evidence = completionEvidenceBody(body);
+    if (!evidence) {
+        return false;
+    }
+    return !/^(?:- )?(?:pending|none yet)\.?$/i.test(evidence.trim());
+}
+function isConcreteCandidate(node, statusRanks) {
+    if (node.source?.imported) {
+        return false;
+    }
+    if (!CONCRETE_GOAL_NEXT_TYPES.has(node.type) || !goal_scope_1.GOAL_SCOPE_ACTIONABLE_TYPES.has(node.type)) {
+        return false;
+    }
+    if (!node.status || !statusRanks.has(node.status)) {
+        return false;
+    }
+    return node.status !== "done";
+}
+function resolveCandidate(index, idOrQid, ws) {
+    const resolved = (0, qid_1.resolveQid)(index, idOrQid, ws);
+    if (resolved.status !== "ok") {
+        return undefined;
+    }
+    return index.nodes[resolved.qid];
+}
+function runGoalShowCommand(options) {
+    const loaded = loadGoal(options.root, options.id, options.ws);
+    const receipt = { action: "showed", goal: goalReceipt(options.root, loaded) };
+    if (options.json) {
+        console.log(JSON.stringify(receipt, null, 2));
+        return;
+    }
+    console.log(`goal: ${loaded.node.qid}`);
+    console.log(`state: ${loaded.frontmatter.goal_state}`);
+    console.log(`condition: ${loaded.frontmatter.goal_condition}`);
+    if (loaded.frontmatter.active_node) {
+        console.log(`active_node: ${loaded.frontmatter.active_node}`);
+    }
+    const checks = toStringList(loaded.frontmatter.required_checks);
+    console.log(`required_checks: ${checks.length === 0 ? "none" : checks.join(", ")}`);
+}
+function runGoalEvaluateCommand(options) {
+    const loaded = loadGoal(options.root, options.id, options.ws);
+    const checks = toStringList(loaded.frontmatter.required_checks).map((command) => ({
+        command,
+        status: "report_only",
+    }));
+    const receipt = {
+        action: "evaluated",
+        goal: goalReceipt(options.root, loaded),
+        report_only: true,
+        runs_scripts: false,
+        checks,
+        completion_evidence_present: hasCompletionEvidence(loaded.body),
+    };
+    if (options.json) {
+        console.log(JSON.stringify(receipt, null, 2));
+        return;
+    }
+    console.log(`goal evaluated: ${loaded.node.qid}`);
+    console.log("report_only: true");
+    console.log(`runs_scripts: false`);
+    console.log(`completion_evidence_present: ${hasCompletionEvidence(loaded.body) ? "yes" : "no"}`);
+    if (checks.length > 0) {
+        console.log("required_checks:");
+        for (const check of checks) {
+            console.log(`- ${check.command} (${check.status})`);
+        }
+    }
+    else {
+        console.log("required_checks: none");
+    }
+}
+function runGoalNextCommand(options) {
+    const loaded = loadGoal(options.root, options.id, options.ws);
+    const statusPreference = loaded.config.work.next.status_preference.map((status) => status.toLowerCase());
+    const statusRanks = new Set(statusPreference);
+    const warnings = [...loaded.warnings];
+    const activeNode = optionalString(loaded.frontmatter.active_node);
+    const scope = (0, goal_scope_1.collectGoalScope)(loaded.index, loaded.node);
+    for (const missing of scope.missingRefs) {
+        warnings.push(`scope_refs references missing node: ${missing}`);
+    }
+    for (const invalid of scope.invalidRefs) {
+        warnings.push(`scope contains non-actionable or unsupported node: ${invalid}`);
+    }
+    if (activeNode) {
+        const node = resolveCandidate(loaded.index, activeNode, loaded.node.ws);
+        if (node && scope.actionableQids.has(node.qid) && isConcreteCandidate(node, statusRanks)) {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    action: "selected",
+                    goal: goalReceipt(options.root, loaded),
+                    goal_source: loaded.resolutionSource,
+                    node,
+                    warnings,
+                }, null, 2));
+                return;
+            }
+            console.log((0, node_card_1.formatNodeCard)(node));
+            return;
+        }
+        warnings.push(`active_node is not an actionable local concrete item: ${activeNode}`);
+    }
+    const candidates = Array.from(scope.actionableQids)
+        .map((qid) => loaded.index.nodes[qid])
+        .filter((node) => Boolean(node))
+        .filter((node) => isConcreteCandidate(node, statusRanks));
+    const sorted = (0, sort_1.sortNodesForNext)(candidates, {
+        statusPreference,
+        priorityMax: loaded.config.work.priority_max,
+    });
+    const selected = sorted[0];
+    if (options.json) {
+        console.log(JSON.stringify({
+            action: "selected",
+            goal: goalReceipt(options.root, loaded),
+            goal_source: loaded.resolutionSource,
+            node: selected ?? null,
+            warnings,
+        }, null, 2));
+        return;
+    }
+    for (const warning of warnings) {
+        console.error(`warning: ${warning}`);
+    }
+    if (!selected) {
+        console.error("no actionable local work found for goal");
+        return;
+    }
+    console.log((0, node_card_1.formatNodeCard)(selected));
+}
+function runGoalSelectCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => {
+        const loaded = loadGoal(options.root, options.id, options.ws);
+        const now = options.now ?? new Date();
+        writeSelectedGoalState(options.root, loaded.node, now);
+        const receipt = {
+            action: "selected_goal",
+            goal: goalReceipt(options.root, loaded),
+            selection: {
+                path: SELECTED_GOAL_STATE_PATH,
+                selected_at: now.toISOString(),
+            },
+        };
+        if (options.json) {
+            console.log(JSON.stringify(receipt, null, 2));
+            return;
+        }
+        console.log(`selected goal: ${loaded.node.qid}`);
+    });
+}
+function runGoalCurrentCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
+    const ws = normalizeWorkspace(options.ws);
+    const warnings = [];
+    let source = "none";
+    let node;
+    const selected = readSelectedGoalState(options.root, warnings);
+    if (selected) {
+        const selectedNode = index.nodes[selected.qid];
+        if (selectedNode && selectedNode.type === "goal" && !selectedNode.source?.imported) {
+            node = selectedNode;
+            source = "selected";
+        }
+        else {
+            warnings.push(`selected goal ${selected.qid} is not available; run \`mdkg goal select <goal-id>\``);
+        }
+    }
+    if (!node) {
+        const active = activeGoalCandidates(index, ws);
+        if (active.length === 1) {
+            node = active[0];
+            source = "unique_active";
+        }
+        else if (active.length > 1) {
+            source = "ambiguous";
+            warnings.push(`multiple active goals found: ${active.map((goal) => goal.qid).join(", ")}`);
+        }
+    }
+    const receipt = {
+        action: "current",
+        goal: node ? {
+            workspace: node.ws,
+            id: node.id,
+            qid: node.qid,
+            path: node.path,
+            type: node.type,
+            title: node.title,
+            status: node.status ?? "",
+            ...(node.priority !== undefined ? { priority: node.priority } : {}),
+            goal_state: String(node.attributes.goal_state ?? ""),
+            goal_condition: String(node.attributes.goal_condition ?? ""),
+            scope_refs: toStringList(node.attributes.scope_refs),
+            active_node: optionalString(node.attributes.active_node),
+            required_skills: toStringList(node.attributes.required_skills),
+            required_checks: toStringList(node.attributes.required_checks),
+            max_iterations: optionalString(node.attributes.max_iterations),
+            blocked_after_attempts: optionalString(node.attributes.blocked_after_attempts),
+        } : null,
+        source,
+        warnings,
+    };
+    if (options.json) {
+        console.log(JSON.stringify(receipt, null, 2));
+        return;
+    }
+    for (const warning of warnings) {
+        console.error(`warning: ${warning}`);
+    }
+    if (!node) {
+        console.error("no selected goal");
+        return;
+    }
+    console.log(`current goal: ${node.qid}`);
+}
+function runGoalClearCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => {
+        const cleared = removeSelectedGoalState(options.root);
+        const receipt = {
+            action: "cleared_goal",
+            path: SELECTED_GOAL_STATE_PATH,
+            cleared,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(receipt, null, 2));
+            return;
+        }
+        console.log(cleared ? "selected goal cleared" : "no selected goal to clear");
+    });
+}
+function runGoalClaimCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => {
+        const loaded = loadGoal(options.root, options.id, options.ws);
+        const resolved = (0, qid_1.resolveQid)(loaded.index, options.workId, loaded.node.ws);
+        if (resolved.status !== "ok") {
+            throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("work", options.workId, resolved, loaded.node.ws));
+        }
+        const node = loaded.index.nodes[resolved.qid];
+        if (!node) {
+            throw new errors_1.NotFoundError(`work not found: ${options.workId}`);
+        }
+        if (node.source?.imported) {
+            throw new errors_1.UsageError(`cannot mutate read-only subgraph node ${node.qid}; update the source workspace for subgraph ${node.source.subgraph_alias}`);
+        }
+        const statusPreference = loaded.config.work.next.status_preference.map((status) => status.toLowerCase());
+        const scope = (0, goal_scope_1.collectGoalScope)(loaded.index, loaded.node);
+        if (!scope.actionableQids.has(node.qid)) {
+            throw new errors_1.UsageError(`${node.qid} is not inside goal scope for ${loaded.node.qid}`);
+        }
+        if (!isConcreteCandidate(node, new Set(statusPreference))) {
+            throw new errors_1.UsageError(`${node.qid} is not an actionable goal work item`);
+        }
+        const now = options.now ?? new Date();
+        loaded.frontmatter.active_node = node.ws === loaded.node.ws ? node.id : node.qid;
+        writeGoalFile(loaded, now);
+        maybeReindex(options.root, loaded.config);
+        (0, event_support_1.appendAutomaticEvent)({
+            root: options.root,
+            ws: loaded.node.ws,
+            kind: "GOAL_CLAIM",
+            status: "ok",
+            refs: [loaded.node.id, node.id],
+            notes: `goal claim via mdkg goal claim`,
+            now,
+        });
+        const receipt = {
+            action: "claimed",
+            goal: goalReceipt(options.root, loaded),
+            node,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(receipt, null, 2));
+            return;
+        }
+        console.log(`goal claim: ${loaded.node.qid} -> ${node.qid}`);
+    });
+}
+function runGoalStateMutationLocked(action, options) {
+    const loaded = loadGoal(options.root, options.id, options.ws);
+    const now = options.now ?? new Date();
+    loaded.frontmatter.goal_state = GOAL_STATE_BY_ACTION[action];
+    loaded.frontmatter.status = ensureStatusAllowed(loaded.config, STATUS_BY_ACTION[action]);
+    writeGoalFile(loaded, now);
+    maybeReindex(options.root, loaded.config);
+    (0, event_support_1.appendAutomaticEvent)({
+        root: options.root,
+        ws: loaded.node.ws,
+        kind: `GOAL_${action.toUpperCase()}`,
+        status: "ok",
+        refs: [loaded.node.id],
+        notes: `goal ${action} via mdkg goal ${action}`,
+        now,
+    });
+    const receipt = {
+        action,
+        goal: goalReceipt(options.root, loaded),
+    };
+    if (options.json) {
+        console.log(JSON.stringify(receipt, null, 2));
+        return;
+    }
+    console.log(`goal ${action}: ${loaded.node.qid}`);
+}
+function runGoalPauseCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => runGoalStateMutationLocked("pause", options));
+}
+function runGoalResumeCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => runGoalStateMutationLocked("resume", options));
+}
+function runGoalDoneCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => runGoalStateMutationLocked("done", options));
+}

package/dist/commands/init.js

@@ -416,6 +416,7 @@ function runInitCommand(options) {
                 ".mdkg/index/*.sqlite-wal",
                 ".mdkg/index/*.sqlite-shm",
                 ".mdkg/index/*.sqlite-journal",
+                ".mdkg/state/",
                 ".mdkg/pack/",
                 ".mdkg/archive/**/source/",
             ])) {

package/dist/commands/new.js

@@ -213,7 +213,9 @@ function runNewCommandLocked(options) {
     let status;
     if (node_1.WORK_TYPES.has(type)) {
         const allowed = new Set(config.work.status_enum.map((value) => value.toLowerCase()));
-        status = statusInput ?? config.work.status_enum[0]?.toLowerCase();
+        status = statusInput ?? (type === "goal" && allowed.has("progress")
+            ? "progress"
+            : config.work.status_enum[0]?.toLowerCase());
         if (!status || !allowed.has(status)) {
             throw new errors_1.UsageError(`--status must be one of ${Array.from(allowed).join(", ")}`);
         }
@@ -329,6 +331,10 @@ function runNewCommandLocked(options) {
         skills: skills.length > 0 ? skills : undefined,
         cases: cases.length > 0 ? cases : undefined,
         supersedes: options.supersedes ? options.supersedes.toLowerCase() : undefined,
+        goal_state: type === "goal" ? (status === "done" ? "achieved" : status === "blocked" ? "blocked" : "active") : undefined,
+        goal_condition: type === "goal" ? title : undefined,
+        max_iterations: type === "goal" ? 25 : undefined,
+        blocked_after_attempts: type === "goal" ? 3 : undefined,
         created: today,
         updated: today,
     });

package/dist/commands/task.js

@@ -22,7 +22,7 @@ const atomic_1 = require("../util/atomic");
 const lock_1 = require("../util/lock");
 const event_support_1 = require("./event_support");
 const checkpoint_1 = require("./checkpoint");
-const MUTABLE_TASK_TYPES = new Set(["task", "bug", "test"]);
+const MUTABLE_TASK_TYPES = new Set(["feat", "task", "bug", "test"]);
 const SKILL_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function parseCsvList(raw) {
     if (!raw) {
@@ -113,7 +113,7 @@ function loadMutableTaskNode(root, idOrQid, wsHint) {
         throw new errors_1.UsageError(`cannot mutate read-only subgraph node ${node.qid}; update the source workspace for subgraph ${node.source.subgraph_alias}`);
     }
     if (!MUTABLE_TASK_TYPES.has(node.type)) {
-        throw new errors_1.UsageError(`mdkg task only supports task, bug, and test nodes; use markdown editing for ${node.type}:${node.id}`);
+        throw new errors_1.UsageError(`mdkg task only supports feat, task, bug, and test nodes; use markdown editing for ${node.type}:${node.id}`);
     }
     const filePath = path_1.default.resolve(root, node.path);
     const content = fs_1.default.readFileSync(filePath, "utf8");

package/dist/commands/upgrade.js

@@ -18,7 +18,7 @@ const skill_mirror_1 = require("./skill_mirror");
 const DEFAULT_SEED_SUBDIR = path_1.default.resolve(__dirname, "..", "init");
 const PROTECTED_CORE_DOCS = new Set([".mdkg/core/SOUL.md", ".mdkg/core/HUMAN.md"]);
 const CREATE_ONLY_PRESERVED = new Set([".mdkg/core/core.md"]);
-const ARCHIVE_RAW_IGNORE_ENTRIES = [".mdkg/archive/**/source/"];
+const LOCAL_STATE_IGNORE_ENTRIES = [".mdkg/state/", ".mdkg/archive/**/source/"];
 function seededInitEvent(nowIso) {
     const event = {
         ts: nowIso,
@@ -307,7 +307,7 @@ function ensureArchiveIgnorePolicy(root, dryRun, summary, changes) {
     const raw = fs_1.default.existsSync(ignorePath) ? fs_1.default.readFileSync(ignorePath, "utf8") : "";
     const lines = raw.split(/\r?\n/);
     const existing = new Set(lines.map((line) => line.trim()).filter(Boolean));
-    const additions = ARCHIVE_RAW_IGNORE_ENTRIES.filter((entry) => !existing.has(entry));
+    const additions = LOCAL_STATE_IGNORE_ENTRIES.filter((entry) => !existing.has(entry));
     if (additions.length === 0) {
         summary.unchanged += 1;
         return;
@@ -316,7 +316,7 @@ function ensureArchiveIgnorePolicy(root, dryRun, summary, changes) {
         path: ".gitignore",
         category: "ignore_policy",
         action: fs_1.default.existsSync(ignorePath) ? "update" : "create",
-        reason: "ignore raw local archive source copies while keeping sidecars and zip caches commit-eligible",
+        reason: "ignore local mdkg state and raw archive source copies while keeping authored graph records commit-eligible",
     });
     if (!dryRun) {
         const suffix = raw.length === 0 || raw.endsWith("\n") ? "" : "\n";

package/dist/commands/validate.js

@@ -142,6 +142,38 @@ function buildWorkspaceMap(config) {
     }
     return workspaces;
 }
+function addReverseEdge(reverse, edgeKey, target, source) {
+    if (!target) {
+        return;
+    }
+    reverse[edgeKey] = reverse[edgeKey] ?? {};
+    reverse[edgeKey][target] = reverse[edgeKey][target] ?? [];
+    reverse[edgeKey][target].push(source);
+}
+function buildReverseEdges(nodes) {
+    const reverse = {};
+    for (const [qid, node] of Object.entries(nodes)) {
+        addReverseEdge(reverse, "epic", node.edges.epic, qid);
+        addReverseEdge(reverse, "parent", node.edges.parent, qid);
+        addReverseEdge(reverse, "prev", node.edges.prev, qid);
+        addReverseEdge(reverse, "next", node.edges.next, qid);
+        for (const target of node.edges.relates) {
+            addReverseEdge(reverse, "relates", target, qid);
+        }
+        for (const target of node.edges.blocked_by) {
+            addReverseEdge(reverse, "blocked_by", target, qid);
+        }
+        for (const target of node.edges.blocks) {
+            addReverseEdge(reverse, "blocks", target, qid);
+        }
+    }
+    for (const targets of Object.values(reverse)) {
+        for (const sources of Object.values(targets)) {
+            sources.sort();
+        }
+    }
+    return reverse;
+}
 function listDirectories(dirPath) {
     if (!fs_1.default.existsSync(dirPath)) {
         return [];
@@ -274,7 +306,7 @@ function runValidateCommand(options) {
         },
         workspaces: buildWorkspaceMap(config),
         nodes,
-        reverse_edges: {},
+        reverse_edges: buildReverseEdges(nodes),
     };
     const subgraphProjection = (0, subgraphs_1.buildSubgraphsIndex)(options.root, config);
     for (const item of subgraphProjection.index.subgraphs) {

package/dist/graph/frontmatter.js

@@ -10,6 +10,14 @@ exports.DEFAULT_FRONTMATTER_KEY_ORDER = [
     "title",
     "status",
     "priority",
+    "goal_state",
+    "goal_condition",
+    "scope_refs",
+    "active_node",
+    "required_skills",
+    "required_checks",
+    "max_iterations",
+    "blocked_after_attempts",
     "epic",
     "parent",
     "prev",