@danalexilewis/taskgraph 0.1.0

package/dist/plan-import/importer.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertTasksAndEdges = upsertTasksAndEdges;
+const uuid_1 = require("uuid");
+const commit_1 = require("../db/commit");
+const neverthrow_1 = require("neverthrow");
+const query_1 = require("../db/query");
+const escape_1 = require("../db/escape");
+function upsertTasksAndEdges(planId, parsedTasks, repoPath, noCommit = false) {
+    const currentTimestamp = (0, query_1.now)();
+    const q = (0, query_1.query)(repoPath);
+    return q
+        .select("task", {
+        columns: ["task_id", "external_key"],
+        where: { plan_id: planId },
+    })
+        .andThen((existingTasksResult) => {
+        return neverthrow_1.ResultAsync.fromPromise((async () => {
+            const existingTasks = existingTasksResult;
+            const externalKeyToTaskId = new Map();
+            existingTasks.forEach((task) => {
+                if (task.external_key) {
+                    externalKeyToTaskId.set(task.external_key, task.task_id);
+                }
+            });
+            let importedTasksCount = 0;
+            for (const parsedTask of parsedTasks) {
+                let taskId = externalKeyToTaskId.get(parsedTask.stableKey);
+                if (taskId) {
+                    // Update existing task
+                    const updateResult = await q.update("task", {
+                        title: parsedTask.title,
+                        feature_key: parsedTask.feature ?? null,
+                        area: parsedTask.area ?? null,
+                        change_type: parsedTask.changeType ?? null,
+                        intent: parsedTask.intent ?? null,
+                        suggested_changes: parsedTask.suggestedChanges ?? null,
+                        acceptance: parsedTask.acceptance.length > 0
+                            ? (0, query_1.jsonObj)({ val: JSON.stringify(parsedTask.acceptance) })
+                            : null,
+                        ...(parsedTask.status !== undefined && {
+                            status: parsedTask.status,
+                        }),
+                        updated_at: currentTimestamp,
+                    }, { task_id: taskId });
+                    if (updateResult.isErr()) {
+                        console.error("Error updating task:", updateResult.error);
+                        throw updateResult.error;
+                    }
+                }
+                else {
+                    // Insert new task
+                    taskId = (0, uuid_1.v4)();
+                    importedTasksCount++;
+                    const taskStatus = parsedTask.status ?? "todo";
+                    const insertResult = await q.insert("task", {
+                        task_id: taskId,
+                        plan_id: planId,
+                        external_key: parsedTask.stableKey,
+                        title: parsedTask.title,
+                        feature_key: parsedTask.feature ?? null,
+                        area: parsedTask.area ?? null,
+                        change_type: parsedTask.changeType ?? null,
+                        intent: parsedTask.intent ?? null,
+                        suggested_changes: parsedTask.suggestedChanges ?? null,
+                        acceptance: parsedTask.acceptance.length > 0
+                            ? (0, query_1.jsonObj)({ val: JSON.stringify(parsedTask.acceptance) })
+                            : null,
+                        status: taskStatus,
+                        created_at: currentTimestamp,
+                        updated_at: currentTimestamp,
+                    });
+                    if (insertResult.isErr()) {
+                        console.error("Error inserting new task:", insertResult.error);
+                        throw insertResult.error;
+                    }
+                    const insertEventResult = await q.insert("event", {
+                        event_id: (0, uuid_1.v4)(),
+                        task_id: taskId,
+                        kind: "created",
+                        body: (0, query_1.jsonObj)({
+                            title: parsedTask.title,
+                            externalKey: parsedTask.stableKey,
+                        }),
+                        created_at: currentTimestamp,
+                    });
+                    if (insertEventResult.isErr()) {
+                        console.error("Error inserting new task event:", insertEventResult.error);
+                        throw insertEventResult.error;
+                    }
+                }
+                // Register for edge resolution (blocker keys may reference tasks just inserted)
+                externalKeyToTaskId.set(parsedTask.stableKey, taskId);
+                // Sync task_domain and task_skill junction tables
+                const delDomainResult = await q.raw(`DELETE FROM \`task_domain\` WHERE task_id = '${(0, escape_1.sqlEscape)(taskId)}'`);
+                if (delDomainResult.isErr())
+                    throw delDomainResult.error;
+                const delSkillResult = await q.raw(`DELETE FROM \`task_skill\` WHERE task_id = '${(0, escape_1.sqlEscape)(taskId)}'`);
+                if (delSkillResult.isErr())
+                    throw delSkillResult.error;
+                for (const domain of parsedTask.domains ?? []) {
+                    const ins = await q.insert("task_domain", {
+                        task_id: taskId,
+                        domain,
+                    });
+                    if (ins.isErr())
+                        throw ins.error;
+                }
+                for (const skill of parsedTask.skills ?? []) {
+                    const ins = await q.insert("task_skill", {
+                        task_id: taskId,
+                        skill,
+                    });
+                    if (ins.isErr())
+                        throw ins.error;
+                }
+                // Handle edges
+                for (const blockerKey of parsedTask.blockedBy) {
+                    const blockerTaskId = externalKeyToTaskId.get(blockerKey);
+                    if (!blockerTaskId) {
+                        console.warn(`Blocker task with stable key '${blockerKey}' not found. Skipping edge creation for task '${parsedTask.stableKey}'.`);
+                        continue;
+                    }
+                    const edgeExistsResult = await q.count("edge", {
+                        from_task_id: blockerTaskId,
+                        to_task_id: taskId,
+                        type: "blocks",
+                    });
+                    if (edgeExistsResult.isErr())
+                        throw edgeExistsResult.error;
+                    const edgeExists = edgeExistsResult.value;
+                    if (edgeExists === 0) {
+                        const insertEdgeResult = await q.insert("edge", {
+                            from_task_id: blockerTaskId,
+                            to_task_id: taskId,
+                            type: "blocks",
+                            reason: "Blocked by plan import",
+                        });
+                        if (insertEdgeResult.isErr()) {
+                            console.error("Error inserting new edge:", insertEdgeResult.error);
+                            throw insertEdgeResult.error;
+                        }
+                    }
+                }
+            }
+            const commitResult = await (0, commit_1.doltCommit)("plan-import: upsert tasks and edges", repoPath, noCommit);
+            if (commitResult.isErr())
+                throw commitResult.error;
+            return {
+                importedTasksCount,
+                createdPlansCount: 0, // This logic is in the cli/import.ts, not here.
+            };
+        })(), (e) => e);
+    });
+}

package/dist/plan-import/parser.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePlanMarkdown = parsePlanMarkdown;
+exports.parseCursorPlan = parseCursorPlan;
+const fs_1 = require("fs");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const CHANGE_TYPES = [
+    "create",
+    "modify",
+    "refactor",
+    "fix",
+    "investigate",
+    "test",
+    "document",
+];
+function isChangeType(s) {
+    return (typeof s === "string" &&
+        CHANGE_TYPES.includes(s));
+}
+function parsePlanMarkdown(filePath) {
+    try {
+        const content = (0, fs_1.readFileSync)(filePath, "utf-8");
+        const lines = content.split("\n");
+        let planTitle = null;
+        let planIntent = null;
+        const tasks = [];
+        let currentTask = null;
+        let inAcceptanceBlock = false;
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (line.startsWith("# ")) {
+                planTitle = line.substring(2).trim();
+            }
+            else if (line.startsWith("INTENT:")) {
+                planIntent = line.substring("INTENT:".length).trim();
+            }
+            else if (trimmedLine.startsWith("TASK:")) {
+                if (currentTask && currentTask.stableKey) {
+                    tasks.push(currentTask);
+                }
+                currentTask = {
+                    stableKey: trimmedLine.substring("TASK:".length).trim(),
+                    blockedBy: [],
+                    acceptance: [],
+                };
+                inAcceptanceBlock = false;
+            }
+            else if (currentTask && trimmedLine.startsWith("TITLE:")) {
+                currentTask.title = trimmedLine.substring("TITLE:".length).trim();
+                inAcceptanceBlock = false;
+            }
+            else if (currentTask && trimmedLine.startsWith("FEATURE:")) {
+                currentTask.feature = trimmedLine.substring("FEATURE:".length).trim();
+                inAcceptanceBlock = false;
+            }
+            else if (currentTask && trimmedLine.startsWith("AREA:")) {
+                currentTask.area = trimmedLine.substring("AREA:".length).trim();
+                inAcceptanceBlock = false;
+            }
+            else if (currentTask && trimmedLine.startsWith("DOMAIN:")) {
+                const parts = trimmedLine
+                    .substring("DOMAIN:".length)
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                currentTask.domains = [...(currentTask.domains || []), ...parts];
+                inAcceptanceBlock = false;
+            }
+            else if (currentTask && trimmedLine.startsWith("SKILL:")) {
+                const parts = trimmedLine
+                    .substring("SKILL:".length)
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                currentTask.skills = [...(currentTask.skills || []), ...parts];
+                inAcceptanceBlock = false;
+            }
+            else if (currentTask && trimmedLine.startsWith("CHANGE_TYPE:")) {
+                const val = trimmedLine.substring("CHANGE_TYPE:".length).trim();
+                if (isChangeType(val))
+                    currentTask.changeType = val;
+                inAcceptanceBlock = false;
+            }
+            else if (currentTask && trimmedLine.startsWith("BLOCKED_BY:")) {
+                const blockers = trimmedLine
+                    .substring("BLOCKED_BY:".length)
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                currentTask.blockedBy = [...(currentTask.blockedBy || []), ...blockers];
+                inAcceptanceBlock = false;
+            }
+            else if (currentTask && trimmedLine.startsWith("ACCEPTANCE:")) {
+                inAcceptanceBlock = true;
+            }
+            else if (currentTask &&
+                inAcceptanceBlock &&
+                trimmedLine.startsWith("-")) {
+                currentTask.acceptance = [
+                    ...(currentTask.acceptance || []),
+                    trimmedLine.substring(1).trim(),
+                ];
+            }
+            else {
+                inAcceptanceBlock = false;
+            }
+        }
+        if (currentTask && currentTask.stableKey) {
+            tasks.push(currentTask);
+        }
+        return (0, neverthrow_1.ok)({ planTitle, planIntent, tasks });
+    }
+    catch (e) {
+        return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.FILE_READ_FAILED, `Failed to read or parse markdown file at ${filePath}`, e));
+    }
+}
+/** Normalize risks from frontmatter to { description, severity, mitigation }[]. */
+function normalizeRisks(raw) {
+    if (!raw || !Array.isArray(raw))
+        return null;
+    return raw
+        .filter((r) => r != null &&
+        typeof r === "object" &&
+        typeof r.description === "string" &&
+        typeof r.severity === "string" &&
+        typeof r.mitigation === "string")
+        .map((r) => ({
+        description: r.description,
+        severity: r.severity,
+        mitigation: r.mitigation,
+    }));
+}
+/** Parses a Cursor Plan file (YAML frontmatter with todos). */
+function parseCursorPlan(filePath) {
+    try {
+        const content = (0, fs_1.readFileSync)(filePath, "utf-8");
+        const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+        if (!frontmatterMatch) {
+            return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.FILE_READ_FAILED, `File ${filePath} does not have YAML frontmatter (--- ... ---)`));
+        }
+        const body = content.slice(frontmatterMatch[0].length).trim() || null;
+        const parsed = js_yaml_1.default.load(frontmatterMatch[1]);
+        if (!parsed || typeof parsed !== "object") {
+            return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.FILE_READ_FAILED, `Invalid YAML frontmatter in ${filePath}`));
+        }
+        const todos = parsed.todos ?? [];
+        if (!Array.isArray(todos)) {
+            return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.FILE_READ_FAILED, `Expected 'todos' to be an array in ${filePath}`));
+        }
+        const tasks = todos
+            .filter((t) => t != null &&
+            typeof t === "object" &&
+            typeof t.id === "string" &&
+            typeof t.content === "string")
+            .map((t) => {
+            const status = t.status === "completed" ? "done" : "todo";
+            const changeType = t.changeType != null && isChangeType(t.changeType)
+                ? t.changeType
+                : undefined;
+            const domains = t.domain === undefined
+                ? undefined
+                : Array.isArray(t.domain)
+                    ? t.domain.filter((x) => typeof x === "string")
+                    : typeof t.domain === "string"
+                        ? [t.domain]
+                        : undefined;
+            const skills = t.skill === undefined
+                ? undefined
+                : Array.isArray(t.skill)
+                    ? t.skill.filter((x) => typeof x === "string")
+                    : typeof t.skill === "string"
+                        ? [t.skill]
+                        : undefined;
+            return {
+                stableKey: t.id,
+                title: t.content,
+                blockedBy: Array.isArray(t.blockedBy) ? t.blockedBy : [],
+                acceptance: [],
+                status,
+                domains: domains?.length ? domains : undefined,
+                skills: skills?.length ? skills : undefined,
+                changeType,
+                intent: typeof t.intent === "string" ? t.intent : undefined,
+                suggestedChanges: typeof t.suggestedChanges === "string"
+                    ? t.suggestedChanges
+                    : undefined,
+            };
+        });
+        const fileTree = typeof parsed.fileTree === "string" ? parsed.fileTree : null;
+        const risks = normalizeRisks(parsed.risks);
+        const tests = Array.isArray(parsed.tests) &&
+            parsed.tests.every((x) => typeof x === "string")
+            ? parsed.tests
+            : null;
+        return (0, neverthrow_1.ok)({
+            planTitle: parsed.name ?? null,
+            planIntent: parsed.overview ?? null,
+            tasks,
+            fileTree: fileTree ?? undefined,
+            risks: risks ?? undefined,
+            tests: tests ?? undefined,
+            body: body ?? undefined,
+        });
+    }
+    catch (e) {
+        return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.FILE_READ_FAILED, `Failed to read or parse Cursor plan at ${filePath}`, e));
+    }
+}

package/dist/template/.cursor/memory.md

@@ -0,0 +1,14 @@
+# Persistent Memory
+
+## Preferences
+
+- (Add repo-specific conventions here: tooling, naming, testing expectations.)
+
+## Patterns
+
+- (Add implementation patterns that worked well in this repo.)
+
+## Corrections
+
+- (Add agent mistakes / environment quirks so they aren’t repeated.)
+

package/dist/template/.cursor/rules/memory.mdc

@@ -0,0 +1,11 @@
+---
+description: Maintain repo-specific persistent memory at .cursor/memory.md
+alwaysApply: true
+---
+
+# Persistent Memory
+
+Every request should start by reading `.cursor/memory.md` to learn repo-specific conventions and prior decisions.
+
+When you discover a tooling quirk, fix a recurring mistake, or establish a useful pattern, update `.cursor/memory.md` at the end of the session.
+

package/dist/template/.cursor/rules/plan-authoring.mdc

@@ -0,0 +1,42 @@
+---
+description: Cursor plan format for tg import (stable ids, dependencies, domain/skill)
+globs: plans/**/*.md
+alwaysApply: false
+---
+
+# Plan Authoring (Cursor Format)
+
+Plans in `plans/` can be imported into TaskGraph with:
+
+```bash
+tg import plans/<file> --plan "<Plan Name>" --format cursor
+```
+
+## Minimal YAML frontmatter
+
+```yaml
+---
+name: Plan Name
+overview: "Brief description of the plan."
+todos:
+  - id: stable-key
+    content: "Small task"
+    status: pending
+  - id: another-task
+    content: "Depends on first"
+    blockedBy: [stable-key]
+---
+```
+
+## Useful fields
+
+- `domain`: string or array → `docs/<domain>.md`
+- `skill`: string or array → `docs/skills/<skill>.md`
+- `changeType`: `create` | `modify` | `refactor` | `fix` | `investigate` | `test` | `document`
+
+## Best practices
+
+- Keep `id` stable over time (kebab-case).
+- Keep tasks scoped (roughly ≤ 90 minutes); split big ones.
+- Use `blockedBy` for true dependencies, not mere sequencing preferences.
+

package/dist/template/.cursor/rules/session-start.mdc

@@ -0,0 +1,18 @@
+---
+description: Run tg status at session start for orientation
+alwaysApply: true
+---
+
+# Session Start
+
+At the start of every session, run:
+
+```bash
+tg status
+```
+
+This surfaces:
+- Plans in progress
+- Tasks stuck in `doing` (may need cleanup)
+- Next runnable tasks
+

package/dist/template/.cursor/rules/taskgraph-workflow.mdc

@@ -0,0 +1,35 @@
+---
+description: TaskGraph plan creation/review + execution loop (per task)
+alwaysApply: true
+---
+
+# TaskGraph Workflow
+
+## Orientation
+
+Before executing work, run `tg status` to see what's outstanding. If there are stale `doing` tasks or forgotten `todo` tasks for completed work, clean them up first.
+
+## Plan creation and review
+
+- Plans live in `plans/<name>.md` (Cursor YAML frontmatter format).
+- After creating a plan: summarize it, then pause for human review. Don’t import or execute until the user says to proceed.
+
+## Execution loop (per task — mandatory)
+
+For EACH task, follow all steps in order.
+
+1. `tg start <taskId>` — must run before doing any work
+2. `tg context <taskId>` — read the printed domain doc paths (`docs/<domain>.md`) and skill guide paths (`docs/skills/<skill>.md`)
+3. Do the work (stay within scope)
+4. `tg done <taskId> --evidence "tests run, commands, commit hashes"` — must run immediately after finishing
+
+## Recovery (out-of-sync tasks)
+
+- Task is `todo` but already done: `tg done <taskId> --force --evidence "completed previously"`
+- Task is `doing` but already done: `tg done <taskId> --evidence "completed previously"`
+
+## When blocked
+
+- `tg block <taskId> --on <blockerId> --reason "..."`
+- If blocker does not exist: create a new task (owner=human), then block on it.
+

package/dist/template/AGENT.md

@@ -0,0 +1,73 @@
+Plan creation and review
+
+- When the user asks for a plan: create `plans/<name>.md` in Cursor format (YAML frontmatter with `name`, `overview`, `todos`). Summarize the plan, then pause and ask for review.
+- Interpret user response using this table:
+
+| User says | Meaning | Agent action |
+|-----------|---------|--------------|
+| proceed, go ahead, execute, run it, let's do it | Approve and execute | Run `tg import plans/<file> --plan "<Plan Name>" --format cursor`, then enter the execution loop below |
+| just add the tasks, add to taskgraph only, import but don't run | Add to graph only | Run `tg import plans/<file> --plan "<Plan Name>" --format cursor`. Do not execute tasks |
+| thanks, that's good, looks good, ok, don't do anything | Acknowledgement only | Do nothing. No import, no execution |
+
+Agent operating loop
+
+- Always begin with: tg status to orient — surface stale tasks, plan state, and other agents' active work (if any).
+- Then: tg next --limit 5 and choose the top runnable task.
+- Before coding: tg show <taskId> and restate:
+  - intent
+  - scope in/out
+  - acceptance checks
+- Then: tg start <taskId> [--agent <name>] — MUST run before any work. When multiple agents may be active, pass --agent so others see who is working.
+- Execute exactly within scope.
+- When done: tg done <taskId> --evidence "..." — MUST run immediately after work is complete.
+  Include in evidence:
+  - tests run
+  - commands output summary
+  - git commit hash(es)
+
+Per-task discipline
+
+- Complete start→work→done for EACH task individually.
+- Never batch-skip transitions (e.g., doing all work then marking all done).
+
+Recovery (out-of-sync tasks)
+
+- Task is `todo` but work is already done: `tg done <taskId> --force --evidence "completed previously"`
+- Task is `doing` but work is already done: `tg done <taskId> --evidence "completed previously"`
+- Run `tg status` after cleanup to verify.
+- Use `--force` only for legitimate out-of-band completion, never to bypass workflow.
+
+Plan completion
+
+After marking the last task in a plan as done, run:
+  tg export markdown --plan <planId> --out plans/<file>
+This updates the plan file with final statuses.
+
+When blocked
+
+- If blocked by missing prerequisite, run:
+  - tg block <taskId> --on <blockerTaskId> --reason "..."
+- If blocker does not exist:
+  - create a new task with owner=human and status todo, then block on it.
+
+Decisions
+
+- If a decision is required to proceed:
+  - create a task: "Decide: …" with owner=human
+  - add a decision_needed event with options + recommendation
+  - stop and ask for approval
+
+Safe graph edits the agent may do without asking
+
+- status transitions (todo→doing→done, blocked when real blocker exists)
+- add a dependency when it's objectively required ("API endpoint must exist before UI integration")
+- split a task when it exceeds ~90 minutes, keeping scope and acceptance intact
+
+Everything else is proposal-only.
+
+Multi-agent awareness (when 2–3 agents work alongside the human)
+
+- Always pass --agent <session-name> on tg start so other agents see who claimed each task.
+- Read "Active work" from tg status before picking a task; avoid overlapping on the same files/area.
+- Use tg note <taskId> --msg "..." to leave breadcrumbs when changing shared interfaces (types, schema, parser).
+- Do not pick a task in the same area as another agent's doing task without human approval.

package/dist/template/docs/backend.md

@@ -0,0 +1,33 @@
+# Backend
+
+This doc is a **domain guide**. Tasks with `domain: backend` should point here (`docs/backend.md`).
+
+## Purpose
+
+- What this domain owns
+- What it explicitly does *not* own
+
+## Key entrypoints
+
+- `src/...`
+- `api/...`
+
+## Data + invariants
+
+- Storage model, important tables/collections
+- Cross-service contracts
+
+## Local dev
+
+- How to run the backend locally
+- Required env vars / secrets handling
+
+## Testing
+
+- Unit/integration/e2e strategy
+- Where tests live and how to run them
+
+## Decisions / gotchas
+
+- Important constraints and historical context
+

package/dist/template/docs/frontend.md

@@ -0,0 +1,31 @@
+# Frontend
+
+This doc is a **domain guide**. Tasks with `domain: frontend` should point here (`docs/frontend.md`).
+
+## Purpose
+
+- What user journeys and surfaces this domain owns
+
+## Key entrypoints
+
+- `src/app/...`
+- `src/components/...`
+
+## State + data fetching
+
+- Where state lives (local, global, server state)
+- Caching/invalidation patterns
+
+## Styling + UI conventions
+
+- Design system / component library conventions
+- Accessibility requirements
+
+## Testing
+
+- Component tests and e2e expectations
+
+## Decisions / gotchas
+
+- Performance footguns, routing rules, etc.
+

package/dist/template/docs/infra.md

@@ -0,0 +1,26 @@
+# Infra
+
+This doc is a **domain guide**. Tasks with `domain: infra` should point here (`docs/infra.md`).
+
+## Purpose
+
+- Deployments, CI/CD, cloud resources, networking, secrets, observability
+
+## Environments
+
+- dev/staging/prod differences
+- Release process
+
+## CI/CD
+
+- How builds/tests run
+- Required checks
+
+## Runbooks
+
+- Common incidents and how to respond
+
+## Decisions / gotchas
+
+- Cost constraints, security constraints, and hard-won lessons
+

package/dist/template/docs/skills/README.md

@@ -0,0 +1,14 @@
+# Skill guides
+
+Tasks can set a `skill` that maps to a guide here. The agent reads `docs/skills/<skill>.md` before starting work.
+
+## Example skills
+
+| Skill | Purpose |
+|-------|---------|
+| [taskgraph-lifecycle-execution](taskgraph-lifecycle-execution.md) | Execute tasks with correct `start → context → done` transitions |
+| [plan-authoring](plan-authoring.md) | Write Cursor-format plans that import cleanly into TaskGraph |
+| [refactoring-safely](refactoring-safely.md) | Behavior-preserving changes: small steps, test before/after |
+
+Use the slug (e.g. `taskgraph-lifecycle-execution`) as the task's `skill` in plan YAML.
+