toolcraft 0.0.15 → 0.0.17

package/dist/cli.js

@@ -921,7 +921,7 @@ function renderGroupHelp(group, breadcrumb, scope, casing, globalOptions, rootUs
             ...formatGlobalOptionRows(globalOptions),
             ...collectSchemaGlobalFieldRows(group, scope, casing, globalLongOptionFlags)
         ];
-        sections.push(`${text.sectionHeader("Global options")}\n${formatHelpOptionList(globalRows)}`);
+        sections.push(`${text.sectionHeader("Options")}\n${formatHelpOptionList(globalRows)}`);
     }
     return renderHelpDocument({
         breadcrumb,

package/node_modules/@poe-code/design-system/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-code/design-system",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/node_modules/@poe-code/task-list/README.md

@@ -140,6 +140,104 @@ await project.move(created.id, { after: "42" });
 
 `gh-issues` exposes one list named `${project.owner}/${project.number}`. `create()` ignores `TaskCreate.id` because GitHub assigns issue numbers. `fire(state)` writes the Project v2 `Status` field to the matching single-select option. `move()` reorders project items.
 
+If the GitHub Project v2 board has not been set up manually, run `poe-code tasks sync <list>` before opening the backend. `openTaskList({ type: "gh-issues" })` no longer requires manual board setup when the board was provisioned with `tasks sync` first.
+
+## Verifying and provisioning the GitHub Project v2 board
+
+Use `verifyGhProject` to check whether a GitHub Project v2 board has the required Project and `Status` single-select options:
+
+```ts
+import { verifyGhProject } from "@poe-code/task-list";
+
+const report = await verifyGhProject({
+  owner: "octo-org",
+  number: 7,
+  requiredStates: ["queued", "agent-running", "human-review", "done", "failed", "archived"],
+  auth: { token: "github-token" }
+});
+```
+
+`VerifyGhProjectOptions` has this shape:
+
+```ts
+interface VerifyGhProjectOptions {
+  owner: string;
+  number: number;
+  requiredStates: readonly string[];
+  client?: GhClient;
+  fetch?: typeof fetch;
+  auth?: { token: string };
+}
+```
+
+`verifyGhProject` returns `Promise<VerifyGhProjectReport>`:
+
+```ts
+interface VerifyGhProjectReport {
+  ok: boolean;
+  project: { id: string; number: number; owner: string } | null;
+  statusField: { id: string; options: readonly string[] } | null;
+  missingProject: boolean;
+  missingStatusField: boolean;
+  missingOptions: readonly string[];
+}
+```
+
+Use `syncGhProject` to provision anything missing:
+
+```ts
+import { syncGhProject } from "@poe-code/task-list";
+
+const report = await syncGhProject({
+  owner: "octo-org",
+  number: 7,
+  requiredStates: ["queued", "agent-running", "human-review", "done", "failed", "archived"],
+  title: "Delivery Board",
+  yes: true,
+  auth: { token: "github-token" }
+});
+```
+
+`SyncGhProjectOptions` extends `VerifyGhProjectOptions`:
+
+```ts
+interface SyncGhProjectOptions extends VerifyGhProjectOptions {
+  title?: string;
+  yes?: boolean;
+}
+```
+
+`syncGhProject` returns `Promise<SyncGhProjectReport>`:
+
+```ts
+interface SyncGhProjectReport extends VerifyGhProjectReport {
+  created: readonly string[];
+  updated: readonly string[];
+}
+```
+
+The CLI exposes the same verification and provisioning flow:
+
+```sh
+poe-code tasks verify <list> --workflow ./WORKFLOW.md --repo octo-org/octo-repo --project octo-org/7 --states queued,agent-running,human-review,done,failed,archived --json
+poe-code tasks sync <list> --workflow ./WORKFLOW.md --repo octo-org/octo-repo --project octo-org/7 --states queued,agent-running,human-review,done,failed,archived --json --yes
+```
+
+`<list>` and `--project` both use `<owner>/<number>` project syntax. `--workflow` defaults to `./WORKFLOW.md`. `--repo` overrides the task repository from workflow frontmatter. `--states` overrides the required state list from workflow frontmatter. `--json` prints the report object as JSON. `--yes` confirms non-interactive sync; it is only used by `poe-code tasks sync`.
+
+| Option | Commands | Behavior |
+| --- | --- | --- |
+| `--workflow <path>` | `verify`, `sync` | Workflow file path. Defaults to `./WORKFLOW.md`. |
+| `--repo <owner/name>` | `verify`, `sync` | GitHub repository owner/name. |
+| `--project <owner/number>` | `verify`, `sync` | GitHub Project v2 owner/number. Overrides `<list>`. |
+| `--states <csv>` | `verify`, `sync` | Required task state names. |
+| `--json` | `verify`, `sync` | Prints the report as JSON. |
+| `--yes` | `sync` | Confirms non-interactive provisioning. |
+
+The `Status` field name and option names are matched case-sensitively. The field must be named `Status`, and required option names must match exactly. For example, `status` is treated as a missing field, and `Done` is treated as missing when the required state is `done`.
+
+In v1, if sync creates a new GitHub Project v2 board, the CLI prints the new project number and does not rewrite `WORKFLOW.md`. The operator must update `WORKFLOW.md` by hand with the printed `<owner>/<number>`.
+
 ## Notes
 
 The package never overwrites existing task files or store files. `defaults.metadata` is applied only when creating new tasks and does not retroactively update existing tasks.

package/node_modules/@poe-code/task-list/dist/backends/gh-issues-sync.d.ts

@@ -0,0 +1,46 @@
+import { type GhClient } from "./gh-issues-client.js";
+export interface VerifyGhProjectOptions {
+    owner: string;
+    number: number;
+    requiredStates: readonly string[];
+    client?: GhClient;
+    fetch?: typeof fetch;
+    auth?: {
+        token: string;
+    };
+}
+export interface VerifyGhProjectReport {
+    ok: boolean;
+    project: {
+        id: string;
+        number: number;
+        owner: string;
+    } | null;
+    statusField: {
+        id: string;
+        options: readonly string[];
+    } | null;
+    missingProject: boolean;
+    missingStatusField: boolean;
+    missingOptions: readonly string[];
+}
+export interface SyncGhProjectOptions extends VerifyGhProjectOptions {
+    title?: string;
+    yes?: boolean;
+}
+export interface SyncGhProjectReport extends VerifyGhProjectReport {
+    created: readonly string[];
+    updated: readonly string[];
+}
+export declare class GhProjectSyncError extends Error {
+    readonly op: "lookup" | "createProject" | "createField" | "createOption";
+    readonly target: string;
+    constructor(options: {
+        op: "lookup" | "createProject" | "createField" | "createOption";
+        target: string;
+        cause?: unknown;
+        message: string;
+    });
+}
+export declare function verifyGhProject(opts: VerifyGhProjectOptions): Promise<VerifyGhProjectReport>;
+export declare function syncGhProject(opts: SyncGhProjectOptions): Promise<SyncGhProjectReport>;

package/node_modules/@poe-code/task-list/dist/backends/gh-issues-sync.js

@@ -0,0 +1,309 @@
+import { PROJECT_ORGANIZATION_QUERY, PROJECT_USER_QUERY } from "./gh-issues.js";
+import { createGhClient } from "./gh-issues-client.js";
+const OWNER_ORGANIZATION_QUERY = `query ProjectOwner($owner: String!) {
+  organization(login: $owner) {
+    id
+  }
+}`;
+const OWNER_USER_QUERY = `query ProjectOwner($owner: String!) {
+  user(login: $owner) {
+    id
+  }
+}`;
+const CREATE_PROJECT_MUTATION = `mutation CreateProject($input: CreateProjectV2Input!) {
+  createProjectV2(input: $input) {
+    projectV2 {
+      id
+      number
+    }
+  }
+}`;
+const CREATE_STATUS_FIELD_MUTATION = `mutation CreateStatusField($input: CreateProjectV2FieldInput!) {
+  createProjectV2Field(input: $input) {
+    projectV2Field {
+      ... on ProjectV2SingleSelectField {
+        id
+        name
+        options { id name }
+      }
+    }
+  }
+}`;
+const CREATE_STATUS_OPTION_MUTATION = `mutation CreateStatusOption($input: CreateProjectV2SingleSelectFieldOptionInput!) {
+  createProjectV2SingleSelectFieldOption(input: $input) {
+    singleSelectFieldOption {
+      id
+      name
+    }
+  }
+}`;
+export class GhProjectSyncError extends Error {
+    op;
+    target;
+    constructor(options) {
+        super(options.message, { cause: options.cause });
+        this.name = "GhProjectSyncError";
+        this.op = options.op;
+        this.target = options.target;
+    }
+}
+export async function verifyGhProject(opts) {
+    const client = resolveGhClient(opts);
+    const target = `project:${opts.owner}/${opts.number}`;
+    const variables = {
+        owner: opts.owner,
+        number: opts.number
+    };
+    let project;
+    try {
+        const organizationResult = await client.graphql(PROJECT_ORGANIZATION_QUERY, variables);
+        project = organizationResult.organization?.projectV2 ?? null;
+        if (project === null) {
+            const userResult = await client.graphql(PROJECT_USER_QUERY, variables);
+            project = userResult.user?.projectV2 ?? null;
+        }
+    }
+    catch (error) {
+        throw new GhProjectSyncError({
+            op: "lookup",
+            target,
+            cause: error,
+            message: "lookup_failed"
+        });
+    }
+    if (project === null) {
+        return {
+            ok: false,
+            project: null,
+            statusField: null,
+            missingProject: true,
+            missingStatusField: true,
+            missingOptions: opts.requiredStates
+        };
+    }
+    const statusField = selectStatusField(project);
+    if (statusField === null) {
+        return {
+            ok: false,
+            project: {
+                id: project.id,
+                number: opts.number,
+                owner: opts.owner
+            },
+            statusField: null,
+            missingProject: false,
+            missingStatusField: true,
+            missingOptions: opts.requiredStates
+        };
+    }
+    const options = statusField.options.map((option) => option.name);
+    const missingOptions = opts.requiredStates.filter((state) => !options.includes(state));
+    return {
+        ok: missingOptions.length === 0,
+        project: {
+            id: project.id,
+            number: opts.number,
+            owner: opts.owner
+        },
+        statusField: {
+            id: statusField.id,
+            options
+        },
+        missingProject: false,
+        missingStatusField: false,
+        missingOptions
+    };
+}
+export async function syncGhProject(opts) {
+    const client = resolveGhClient(opts);
+    const verified = await verifyGhProject({ ...opts, client });
+    const created = [];
+    if (verified.ok) {
+        return {
+            ...verified,
+            created,
+            updated: []
+        };
+    }
+    let project = verified.project;
+    let statusField = verified.statusField;
+    let missingOptions = [...verified.missingOptions];
+    if (project === null) {
+        project = await createProject(client, opts);
+        created.push("project");
+        statusField = null;
+        missingOptions = [...opts.requiredStates];
+    }
+    if (statusField === null) {
+        const createdStatusField = await createStatusField(client, project.id);
+        statusField = createdStatusField;
+        created.push("field");
+        missingOptions = opts.requiredStates.filter((state) => !createdStatusField.options.includes(state));
+    }
+    if (missingOptions.length > 0) {
+        for (const optionName of missingOptions) {
+            await createStatusOption(client, statusField.id, optionName);
+            created.push(`option:${optionName}`);
+        }
+        statusField = {
+            id: statusField.id,
+            options: [...statusField.options, ...missingOptions]
+        };
+        missingOptions = [];
+    }
+    return {
+        ok: statusField !== null && missingOptions.length === 0,
+        project,
+        statusField,
+        missingProject: false,
+        missingStatusField: statusField === null,
+        missingOptions,
+        created,
+        updated: []
+    };
+}
+async function createProject(client, opts) {
+    const target = `${opts.owner}/${opts.number}`;
+    try {
+        const ownerId = await lookupOwnerId(client, opts.owner);
+        const result = await client.graphql(CREATE_PROJECT_MUTATION, {
+            input: {
+                ownerId,
+                title: opts.title ?? `${opts.owner}/${opts.number}`
+            }
+        });
+        const project = result.createProjectV2?.projectV2;
+        if (project === undefined || project === null) {
+            throw new Error("createProjectV2 returned no project");
+        }
+        return {
+            id: project.id,
+            number: project.number,
+            owner: opts.owner
+        };
+    }
+    catch (error) {
+        throw new GhProjectSyncError({
+            op: "createProject",
+            target,
+            cause: error,
+            message: errorMessage(error)
+        });
+    }
+}
+async function lookupOwnerId(client, owner) {
+    const organizationResult = await client.graphql(OWNER_ORGANIZATION_QUERY, {
+        owner
+    });
+    const organizationId = organizationResult.organization?.id;
+    if (organizationId !== undefined) {
+        return organizationId;
+    }
+    const userResult = await client.graphql(OWNER_USER_QUERY, {
+        owner
+    });
+    const userId = userResult.user?.id;
+    if (userId !== undefined) {
+        return userId;
+    }
+    throw new Error(`GitHub owner not found: ${owner}`);
+}
+async function createStatusField(client, projectId) {
+    try {
+        const result = await client.graphql(CREATE_STATUS_FIELD_MUTATION, {
+            input: {
+                projectId,
+                dataType: "SINGLE_SELECT",
+                name: "Status",
+                singleSelectOptions: []
+            }
+        });
+        const field = result.createProjectV2Field?.projectV2Field;
+        if (!isStatusField(field)) {
+            throw new Error("createProjectV2Field returned no Status field");
+        }
+        return {
+            id: field.id,
+            options: field.options.map((option) => option.name)
+        };
+    }
+    catch (error) {
+        throw new GhProjectSyncError({
+            op: "createField",
+            target: "Status",
+            cause: error,
+            message: errorMessage(error)
+        });
+    }
+}
+async function createStatusOption(client, fieldId, name) {
+    try {
+        await client.graphql(CREATE_STATUS_OPTION_MUTATION, {
+            input: {
+                fieldId,
+                name,
+                color: "GRAY"
+            }
+        });
+    }
+    catch (error) {
+        throw new GhProjectSyncError({
+            op: "createOption",
+            target: name,
+            cause: error,
+            message: errorMessage(error)
+        });
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function resolveGhClient(opts) {
+    if (opts.client !== undefined) {
+        return opts.client;
+    }
+    const token = opts.auth?.token;
+    if (token === undefined || token.length === 0) {
+        throw new GhProjectSyncError({
+            op: "lookup",
+            target: "auth",
+            message: "missing_auth"
+        });
+    }
+    return createGhClient({
+        token,
+        fetch: opts.fetch
+    });
+}
+function selectStatusField(project) {
+    const fields = project.fields?.nodes?.filter(isStatusField) ?? [];
+    const exactStatusField = fields.find((field) => field.name === "Status");
+    if (exactStatusField !== undefined) {
+        return exactStatusField;
+    }
+    if (isStatusField(project.field) && isExactStatusField(project.field)) {
+        return project.field;
+    }
+    return null;
+}
+function isExactStatusField(field) {
+    return field.name === undefined || field.name === "Status";
+}
+function isStatusOption(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "id" in value &&
+        typeof value.id === "string" &&
+        "name" in value &&
+        typeof value.name === "string");
+}
+function isStatusField(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "id" in value &&
+        typeof value.id === "string" &&
+        (!("name" in value) || typeof value.name === "string") &&
+        "options" in value &&
+        Array.isArray(value.options) &&
+        value.options.every(isStatusOption));
+}

package/node_modules/@poe-code/task-list/dist/backends/gh-issues.d.ts

@@ -1,4 +1,6 @@
 import type { TaskDefaults, TaskList } from "../types.js";
+export declare const PROJECT_ORGANIZATION_QUERY = "query Project($owner: String!, $number: Int!) {\n  organization(login: $owner) {\n    projectV2(number: $number) {\n      id\n      title\n      field(name: \"Status\") {\n        ... on ProjectV2SingleSelectField {\n          id\n          name\n          options { id name }\n        }\n      }\n      fields(first: 100) {\n        nodes {\n          ... on ProjectV2SingleSelectField {\n            id\n            name\n            options { id name }\n          }\n        }\n      }\n    }\n  }\n}";
+export declare const PROJECT_USER_QUERY = "query Project($owner: String!, $number: Int!) {\n  user(login: $owner) {\n    projectV2(number: $number) {\n      id\n      title\n      field(name: \"Status\") {\n        ... on ProjectV2SingleSelectField {\n          id\n          name\n          options { id name }\n        }\n      }\n      fields(first: 100) {\n        nodes {\n          ... on ProjectV2SingleSelectField {\n            id\n            name\n            options { id name }\n          }\n        }\n      }\n    }\n  }\n}";
 export interface GhIssuesBackendDeps {
     repo: string;
     project: {

package/node_modules/@poe-code/task-list/dist/backends/gh-issues.js

@@ -2,7 +2,7 @@ import { eventsFromState, findEvent } from "../state-machine.js";
 import { AnchorNotFoundError, InvalidTransitionError, OrderMismatchError, TaskNotFoundError } from "../types.js";
 import { createGhClient } from "./gh-issues-client.js";
 import { applyOrder, sortTasks } from "./utils.js";
-const PROJECT_ORGANIZATION_QUERY = `query Project($owner: String!, $number: Int!) {
+export const PROJECT_ORGANIZATION_QUERY = `query Project($owner: String!, $number: Int!) {
   organization(login: $owner) {
     projectV2(number: $number) {
       id
@@ -10,13 +10,23 @@ const PROJECT_ORGANIZATION_QUERY = `query Project($owner: String!, $number: Int!
       field(name: "Status") {
         ... on ProjectV2SingleSelectField {
           id
+          name
           options { id name }
         }
       }
+      fields(first: 100) {
+        nodes {
+          ... on ProjectV2SingleSelectField {
+            id
+            name
+            options { id name }
+          }
+        }
+      }
     }
   }
 }`;
-const PROJECT_USER_QUERY = `query Project($owner: String!, $number: Int!) {
+export const PROJECT_USER_QUERY = `query Project($owner: String!, $number: Int!) {
   user(login: $owner) {
     projectV2(number: $number) {
       id
@@ -24,9 +34,19 @@ const PROJECT_USER_QUERY = `query Project($owner: String!, $number: Int!) {
       field(name: "Status") {
         ... on ProjectV2SingleSelectField {
           id
+          name
           options { id name }
         }
       }
+      fields(first: 100) {
+        nodes {
+          ... on ProjectV2SingleSelectField {
+            id
+            name
+            options { id name }
+          }
+        }
+      }
     }
   }
 }`;

package/node_modules/@poe-code/task-list/dist/backends/markdown-dir.js

@@ -22,6 +22,10 @@ const RESERVED_FRONTMATTER_KEYS = new Set([
     "state",
     "version"
 ]);
+const PASSTHROUGH_RESERVED_FRONTMATTER_KEYS = new Set(["description", "name", "state"]);
+function resolveListLayout(deps) {
+    return deps.singleList ? { kind: "single", name: deps.singleList } : { kind: "multi" };
+}
 function validateListName(name) {
     if (name.length === 0 ||
         name === ARCHIVE_DIRECTORY_NAME ||
@@ -45,17 +49,19 @@ function parseQualifiedId(qualifiedId) {
         id: validateTaskId(qualifiedId.slice(separatorIndex + 1))
     };
 }
-function listPath(rootPath, list) {
-    return path.join(rootPath, list);
+function listPath(rootPath, layout, list) {
+    return layout.kind === "single" ? rootPath : path.join(rootPath, list);
 }
-function archiveDirectoryPath(rootPath, list) {
-    return path.join(listPath(rootPath, list), ARCHIVE_DIRECTORY_NAME);
+function archiveDirectoryPath(rootPath, layout, list) {
+    return layout.kind === "single"
+        ? path.join(rootPath, ARCHIVE_DIRECTORY_NAME)
+        : path.join(rootPath, list, ARCHIVE_DIRECTORY_NAME);
 }
 function activeTaskFilename(id, order, width) {
     return `${String(order).padStart(width, "0")}-${id}${MARKDOWN_EXTENSION}`;
 }
-function archivedTaskPath(rootPath, list, id) {
-    return path.join(archiveDirectoryPath(rootPath, list), `${id}${MARKDOWN_EXTENSION}`);
+function archivedTaskPath(rootPath, layout, list, id) {
+    return path.join(archiveDirectoryPath(rootPath, layout, list), `${id}${MARKDOWN_EXTENSION}`);
 }
 function isMarkdownFile(entryName) {
     return entryName.endsWith(MARKDOWN_EXTENSION);
@@ -67,7 +73,11 @@ function isLockFile(entryName) {
     return entryName.endsWith(".lock");
 }
 function isValidTaskIdShape(id) {
-    return id.length > 0 && !id.startsWith(".") && !id.includes("/") && !id.includes("\\") && !id.includes("..");
+    return (id.length > 0 &&
+        !id.startsWith(".") &&
+        !id.includes("/") &&
+        !id.includes("\\") &&
+        !id.includes(".."));
 }
 function parseActiveFilename(entryName) {
     if (!isMarkdownFile(entryName))
@@ -94,9 +104,13 @@ function malformedTask(filePath, field) {
 function stripTrailingCarriageReturn(line) {
     return line.endsWith("\r") ? line.slice(0, -1) : line;
 }
-function splitTaskDocument(content, filePath) {
+function splitTaskDocument(content, filePath, mode) {
     const lines = content.split("\n");
-    if (lines.length === 0 || stripTrailingCarriageReturn(lines[0]) !== "---") {
+    const hasFrontmatterBlock = lines.length > 0 && stripTrailingCarriageReturn(lines[0]) === "---";
+    if (!hasFrontmatterBlock) {
+        if (mode === "passthrough") {
+            return { frontmatter: "", body: content };
+        }
         throw malformedTask(filePath, "frontmatter");
     }
     let closingIndex = -1;
@@ -153,16 +167,20 @@ function assertValidTaskRecord(frontmatter, filePath, validStates) {
         throw malformedTask(filePath, "description");
     }
 }
-function metadataFromFrontmatter(frontmatter) {
+function reservedFrontmatterKeys(mode) {
+    return mode === "passthrough" ? PASSTHROUGH_RESERVED_FRONTMATTER_KEYS : RESERVED_FRONTMATTER_KEYS;
+}
+function metadataFromFrontmatter(frontmatter, mode) {
     const metadata = {};
+    const reservedKeys = reservedFrontmatterKeys(mode);
     for (const [key, value] of Object.entries(frontmatter)) {
-        if (!RESERVED_FRONTMATTER_KEYS.has(key)) {
+        if (!reservedKeys.has(key)) {
             metadata[key] = value;
         }
     }
     return metadata;
 }
-function createTask(list, id, frontmatter, body) {
+function createTask(list, id, frontmatter, body, mode) {
     return {
         list,
         id,
@@ -170,7 +188,7 @@ function createTask(list, id, frontmatter, body) {
         name: frontmatter.name,
         state: frontmatter.state,
         description: body,
-        metadata: metadataFromFrontmatter(frontmatter)
+        metadata: metadataFromFrontmatter(frontmatter, mode)
     };
 }
 function serializeTaskDocument(frontmatter, description) {
@@ -194,15 +212,33 @@ async function ensureRootPath(deps) {
     }
     await deps.fs.stat(deps.path);
 }
-async function readTaskFile(fs, list, id, filePath, validStates) {
+async function readTaskFile(fs, list, id, filePath, validStates, initialState, mode) {
     const content = await fs.readFile(filePath, "utf8");
-    const document = splitTaskDocument(content, filePath);
-    const frontmatter = readFrontmatter(document.frontmatter, filePath);
-    assertValidTaskRecord(frontmatter, filePath, validStates);
+    const document = splitTaskDocument(content, filePath, mode);
+    const frontmatter = mode === "passthrough" && document.frontmatter.trim().length === 0
+        ? {}
+        : readFrontmatter(document.frontmatter, filePath);
+    if (mode !== "passthrough") {
+        assertValidTaskRecord(frontmatter, filePath, validStates);
+        return {
+            path: filePath,
+            frontmatter,
+            task: createTask(list, id, frontmatter, document.body, mode)
+        };
+    }
+    const parsedFilename = parseActiveFilename(path.basename(filePath));
+    const defaultName = parsedFilename?.id ?? id;
+    const effectiveFrontmatter = {
+        ...frontmatter,
+        name: typeof frontmatter.name === "string" ? frontmatter.name : defaultName,
+        state: typeof frontmatter.state === "string" && validStates.has(frontmatter.state)
+            ? frontmatter.state
+            : initialState
+    };
     return {
         path: filePath,
         frontmatter,
-        task: createTask(list, id, frontmatter, document.body)
+        task: createTask(list, id, effectiveFrontmatter, document.body, mode)
     };
 }
 async function findActiveTaskFilename(fs, listDirectoryPath, id) {
@@ -217,8 +253,8 @@ async function findActiveTaskFilename(fs, listDirectoryPath, id) {
     }
     return undefined;
 }
-async function findTaskLocation(fs, rootPath, list, id) {
-    const listDirectoryPath = listPath(rootPath, list);
+async function findTaskLocation(fs, rootPath, layout, list, id) {
+    const listDirectoryPath = listPath(rootPath, layout, list);
     const activeName = await findActiveTaskFilename(fs, listDirectoryPath, id);
     if (activeName) {
         const activePath = path.join(listDirectoryPath, activeName);
@@ -227,71 +263,91 @@ async function findTaskLocation(fs, rootPath, list, id) {
             return { archived: false, path: activePath };
         }
     }
-    const archivedPath = archivedTaskPath(rootPath, list, id);
+    const archivedPath = archivedTaskPath(rootPath, layout, list, id);
     const archivedStat = await statIfExists(fs, archivedPath);
     if (archivedStat?.isFile()) {
         return { archived: true, path: archivedPath };
     }
     return undefined;
 }
-async function readTaskAtLocation(fs, rootPath, list, id, validStates) {
-    const location = await findTaskLocation(fs, rootPath, list, id);
+async function readTaskAtLocation(fs, rootPath, layout, list, id, validStates, initialState, mode) {
+    const location = await findTaskLocation(fs, rootPath, layout, list, id);
     if (!location) {
         throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
     }
-    return readTaskFile(fs, list, id, location.path, validStates);
+    return readTaskFile(fs, list, id, location.path, validStates, initialState, mode);
 }
-function createdFrontmatter(defaults, input, initialState) {
-    const frontmatter = {
-        $schema: TASK_SCHEMA_ID,
-        kind: TASK_KIND,
-        version: TASK_VERSION,
-        name: input.name,
-        state: initialState
-    };
+function createdFrontmatter(defaults, input, initialState, mode) {
+    const frontmatter = mode !== "passthrough"
+        ? {
+            $schema: TASK_SCHEMA_ID,
+            kind: TASK_KIND,
+            version: TASK_VERSION,
+            name: input.name,
+            state: initialState
+        }
+        : {
+            name: input.name,
+            state: initialState
+        };
+    const reservedKeys = reservedFrontmatterKeys(mode);
     for (const [key, value] of Object.entries(defaults.metadata)) {
-        if (!RESERVED_FRONTMATTER_KEYS.has(key)) {
+        if (!reservedKeys.has(key)) {
             frontmatter[key] = value;
         }
     }
     for (const [key, value] of Object.entries(input.metadata ?? {})) {
-        if (!RESERVED_FRONTMATTER_KEYS.has(key)) {
+        if (!reservedKeys.has(key)) {
             frontmatter[key] = value;
         }
     }
     frontmatter.created = new Date().toISOString();
     return frontmatter;
 }
-function updatedFrontmatter(existingFrontmatter, task, patch) {
-    const nextFrontmatter = {
-        ...existingFrontmatter,
-        $schema: existingFrontmatter.$schema ?? TASK_SCHEMA_ID,
-        kind: existingFrontmatter.kind ?? TASK_KIND,
-        version: existingFrontmatter.version ?? TASK_VERSION,
-        name: patch.name ?? task.name,
-        state: task.state
-    };
+function updatedFrontmatter(existingFrontmatter, task, patch, mode) {
+    const nextFrontmatter = mode !== "passthrough"
+        ? {
+            ...existingFrontmatter,
+            $schema: existingFrontmatter.$schema ?? TASK_SCHEMA_ID,
+            kind: existingFrontmatter.kind ?? TASK_KIND,
+            version: existingFrontmatter.version ?? TASK_VERSION,
+            name: patch.name ?? task.name,
+            state: task.state
+        }
+        : {
+            ...existingFrontmatter,
+            name: patch.name ?? task.name,
+            state: task.state
+        };
+    const reservedKeys = reservedFrontmatterKeys(mode);
     for (const [key, value] of Object.entries(patch.metadata ?? {})) {
-        if (!RESERVED_FRONTMATTER_KEYS.has(key)) {
+        if (!reservedKeys.has(key)) {
             nextFrontmatter[key] = value;
         }
     }
     return nextFrontmatter;
 }
-function transitionedFrontmatter(existingFrontmatter, task, to) {
-    return {
-        ...existingFrontmatter,
-        $schema: existingFrontmatter.$schema ?? TASK_SCHEMA_ID,
-        kind: existingFrontmatter.kind ?? TASK_KIND,
-        version: existingFrontmatter.version ?? TASK_VERSION,
-        name: task.name,
-        state: to
-    };
-}
-function firedFrontmatter(existingFrontmatter, task, to, metadataPatch) {
-    const nextFrontmatter = transitionedFrontmatter(existingFrontmatter, task, to);
+function transitionedFrontmatter(existingFrontmatter, task, to, mode) {
+    return mode !== "passthrough"
+        ? {
+            ...existingFrontmatter,
+            $schema: existingFrontmatter.$schema ?? TASK_SCHEMA_ID,
+            kind: existingFrontmatter.kind ?? TASK_KIND,
+            version: existingFrontmatter.version ?? TASK_VERSION,
+            name: task.name,
+            state: to
+        }
+        : {
+            ...existingFrontmatter,
+            name: task.name,
+            state: to
+        };
+}
+function firedFrontmatter(existingFrontmatter, task, to, mode, metadataPatch) {
+    const nextFrontmatter = transitionedFrontmatter(existingFrontmatter, task, to, mode);
+    const reservedKeys = reservedFrontmatterKeys(mode);
     for (const [key, value] of Object.entries(metadataPatch ?? {})) {
-        if (!RESERVED_FRONTMATTER_KEYS.has(key)) {
+        if (!reservedKeys.has(key)) {
             nextFrontmatter[key] = value;
         }
     }
@@ -312,8 +368,8 @@ function assertUpdateDoesNotSetState(patch) {
         throw new Error('Tasks.update() does not accept "state"; use fire() to change task state.');
     }
 }
-function createTasksView(deps, list) {
-    const listDirectoryPath = listPath(deps.path, list);
+function createTasksView(deps, layout, list) {
+    const listDirectoryPath = listPath(deps.path, layout, list);
     const stateMachine = resolveStateMachine(deps.stateMachine);
     const validStates = new Set(stateMachine.states);
     async function readActiveEntries() {
@@ -345,13 +401,13 @@ function createTasksView(deps, list) {
         const tasks = new Map();
         for (const entry of entries) {
             const filePath = path.join(listDirectoryPath, entry.filename);
-            const file = await readTaskFile(deps.fs, list, entry.id, filePath, validStates);
+            const file = await readTaskFile(deps.fs, list, entry.id, filePath, validStates, stateMachine.initial, deps.frontmatterMode);
             tasks.set(entry.id, { task: file.task, raw: file.frontmatter });
         }
         return { entries, tasks };
     }
     async function readArchivedTasks() {
-        const archivePath = archiveDirectoryPath(deps.path, list);
+        const archivePath = archiveDirectoryPath(deps.path, layout, list);
         const entries = await readDirectoryNames(deps.fs, archivePath);
         const result = [];
         for (const entryName of entries) {
@@ -362,35 +418,109 @@ function createTasksView(deps, list) {
             if (!entryStat?.isFile())
                 continue;
             const id = entryName.slice(0, -MARKDOWN_EXTENSION.length);
-            const file = await readTaskFile(deps.fs, list, id, entryPath, validStates);
+            const file = await readTaskFile(deps.fs, list, id, entryPath, validStates, stateMachine.initial, deps.frontmatterMode);
             result.push({ task: file.task, raw: file.frontmatter });
         }
         return result.sort((left, right) => left.task.qualifiedId.localeCompare(right.task.qualifiedId));
     }
+    async function renameActiveEntries(entries, desiredOrdersById) {
+        const staged = [];
+        const maxOrder = Math.max(...desiredOrdersById.values(), entries.length);
+        const width = padWidthForCount(maxOrder);
+        for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            const desiredOrder = desiredOrdersById.get(entry.id);
+            if (desiredOrder === undefined)
+                continue;
+            const desiredFilename = activeTaskFilename(entry.id, desiredOrder, width);
+            if (entry.filename !== desiredFilename) {
+                const fromPath = path.join(listDirectoryPath, entry.filename);
+                const stagingPath = path.join(listDirectoryPath, `${desiredFilename}.staging-${process.pid}-${index}`);
+                const targetPath = path.join(listDirectoryPath, desiredFilename);
+                await deps.fs.rename(fromPath, stagingPath);
+                staged.push({ from: stagingPath, to: targetPath });
+            }
+        }
+        for (const entry of staged) {
+            await deps.fs.rename(entry.from, entry.to);
+        }
+    }
     async function rewriteListPrefixes(orderedIds) {
         const entries = await readActiveEntries();
         const byId = new Map(entries.map((entry) => [entry.id, entry]));
-        const width = padWidthForCount(orderedIds.length);
+        const desiredOrdersById = new Map();
         for (let index = 0; index < orderedIds.length; index += 1) {
             const id = orderedIds[index];
             const entry = byId.get(id);
             if (!entry)
                 continue;
-            const desiredFilename = activeTaskFilename(id, index + 1, width);
-            if (entry.filename !== desiredFilename) {
-                const fromPath = path.join(listDirectoryPath, entry.filename);
-                const stagingPath = path.join(listDirectoryPath, `${desiredFilename}.staging-${process.pid}-${index}`);
-                await deps.fs.rename(fromPath, stagingPath);
-                entry.filename = path.basename(stagingPath);
+            desiredOrdersById.set(id, index + 1);
+        }
+        await renameActiveEntries(entries, desiredOrdersById);
+    }
+    function entryOrder(entry, index) {
+        return entry.order ?? index + 1;
+    }
+    async function rewriteMovedPrefix(movedId, orderedIds) {
+        const entries = await readActiveEntries();
+        const byId = new Map(entries.map((entry, index) => [entry.id, { entry, index }]));
+        const movedIndex = orderedIds.indexOf(movedId);
+        const moved = byId.get(movedId);
+        if (movedIndex < 0 || moved === undefined)
+            return;
+        const desiredOrdersById = new Map();
+        const previousId = movedIndex > 0 ? orderedIds[movedIndex - 1] : undefined;
+        const nextId = movedIndex < orderedIds.length - 1 ? orderedIds[movedIndex + 1] : undefined;
+        const previous = previousId === undefined ? undefined : byId.get(previousId);
+        const next = nextId === undefined ? undefined : byId.get(nextId);
+        if (previous !== undefined && next === undefined) {
+            desiredOrdersById.set(movedId, entryOrder(previous.entry, previous.index) + 1);
+            await renameActiveEntries(entries, desiredOrdersById);
+            return;
+        }
+        if (previous === undefined && next !== undefined) {
+            const nextOrder = entryOrder(next.entry, next.index);
+            if (nextOrder > 1) {
+                desiredOrdersById.set(movedId, nextOrder - 1);
+                await renameActiveEntries(entries, desiredOrdersById);
+                return;
+            }
+            desiredOrdersById.set(movedId, 1);
+            let lastOrder = 1;
+            for (let index = movedIndex + 1; index < orderedIds.length; index += 1) {
+                const candidate = byId.get(orderedIds[index]);
+                if (candidate === undefined)
+                    continue;
+                const currentOrder = entryOrder(candidate.entry, candidate.index);
+                if (currentOrder > lastOrder)
+                    break;
+                lastOrder += 1;
+                desiredOrdersById.set(candidate.entry.id, lastOrder);
             }
+            await renameActiveEntries(entries, desiredOrdersById);
+            return;
         }
-        const refreshed = await readDirectoryNames(deps.fs, listDirectoryPath);
-        for (const entryName of refreshed) {
-            const stagingMatch = /\.staging-\d+-\d+$/.exec(entryName);
-            if (!stagingMatch)
-                continue;
-            const desiredName = entryName.slice(0, stagingMatch.index);
-            await deps.fs.rename(path.join(listDirectoryPath, entryName), path.join(listDirectoryPath, desiredName));
+        if (previous !== undefined && next !== undefined) {
+            const previousOrder = entryOrder(previous.entry, previous.index);
+            const nextOrder = entryOrder(next.entry, next.index);
+            if (nextOrder - previousOrder > 1) {
+                desiredOrdersById.set(movedId, previousOrder + 1);
+                await renameActiveEntries(entries, desiredOrdersById);
+                return;
+            }
+            let lastOrder = previousOrder + 1;
+            desiredOrdersById.set(movedId, lastOrder);
+            for (let index = movedIndex + 1; index < orderedIds.length; index += 1) {
+                const candidate = byId.get(orderedIds[index]);
+                if (candidate === undefined)
+                    continue;
+                const currentOrder = entryOrder(candidate.entry, candidate.index);
+                if (currentOrder > lastOrder)
+                    break;
+                lastOrder += 1;
+                desiredOrdersById.set(candidate.entry.id, lastOrder);
+            }
+            await renameActiveEntries(entries, desiredOrdersById);
         }
     }
     async function withListLock(action) {
@@ -411,9 +541,22 @@ function createTasksView(deps, list) {
         validateTaskId(id);
         return withListLock(action);
     }
+    async function withLocatedTaskLock(location, action) {
+        const release = await acquireFileLock(location.path, {
+            fs: deps.fs,
+            staleMs: deps.lockStaleMs,
+            retries: deps.lockRetries
+        });
+        try {
+            return await action();
+        }
+        finally {
+            await release();
+        }
+    }
     async function getTaskFile(id) {
         validateTaskId(id);
-        return readTaskAtLocation(deps.fs, deps.path, list, id, validStates);
+        return readTaskAtLocation(deps.fs, deps.path, layout, list, id, validStates, stateMachine.initial, deps.frontmatterMode);
     }
     function assertFireableTaskEvent(task, eventName) {
         const event = findEvent(stateMachine, task.state, eventName);
@@ -457,7 +600,7 @@ function createTasksView(deps, list) {
             validateTaskId(input.id);
             await deps.fs.mkdir(listDirectoryPath, { recursive: true });
             return withListLock(async () => {
-                const existing = await findTaskLocation(deps.fs, deps.path, list, input.id);
+                const existing = await findTaskLocation(deps.fs, deps.path, layout, list, input.id);
                 if (existing) {
                     throw new TaskAlreadyExistsError(`Task "${list}/${input.id}" already exists.`);
                 }
@@ -467,24 +610,24 @@ function createTasksView(deps, list) {
                 const width = padWidthForCount(activeEntries.length + 1);
                 const filename = activeTaskFilename(input.id, nextOrder, width);
                 const targetPath = path.join(listDirectoryPath, filename);
-                const frontmatter = createdFrontmatter(deps.defaults, input, stateMachine.initial);
+                const frontmatter = createdFrontmatter(deps.defaults, input, stateMachine.initial, deps.frontmatterMode);
                 const description = input.description ?? "";
                 await writeAtomically(deps.fs, targetPath, serializeTaskDocument(frontmatter, description));
-                return createTask(list, input.id, frontmatter, description);
+                return createTask(list, input.id, frontmatter, description, deps.frontmatterMode);
             });
         },
         async update(id, patch) {
             assertUpdateDoesNotSetState(patch);
             return withTaskLock(id, async () => {
                 const existing = await getTaskFile(id);
-                const nextFrontmatter = updatedFrontmatter(existing.frontmatter, existing.task, patch);
+                const nextFrontmatter = updatedFrontmatter(existing.frontmatter, existing.task, patch, deps.frontmatterMode);
                 const description = patch.description ?? existing.task.description;
                 await writeAtomically(deps.fs, existing.path, serializeTaskDocument(nextFrontmatter, description));
-                return createTask(list, id, nextFrontmatter, description);
+                return createTask(list, id, nextFrontmatter, description, deps.frontmatterMode);
             });
         },
         async fire(id, eventName, opts) {
-            return withTaskLock(id, async () => {
+            const fireTask = async () => {
                 const existing = await getTaskFile(id);
                 const event = assertFireableTaskEvent(existing.task, eventName);
                 const guardResult = event.guard?.(existing.task) ?? true;
@@ -497,17 +640,17 @@ function createTasksView(deps, list) {
                     });
                 }
                 await event.onExit?.(existing.task);
-                const nextFrontmatter = firedFrontmatter(existing.frontmatter, existing.task, event.to, opts?.metadataPatch);
-                const nextTask = createTask(list, id, nextFrontmatter, existing.task.description);
+                const nextFrontmatter = firedFrontmatter(existing.frontmatter, existing.task, event.to, deps.frontmatterMode, opts?.metadataPatch);
+                const nextTask = createTask(list, id, nextFrontmatter, existing.task.description, deps.frontmatterMode);
                 const serializedTask = serializeTaskDocument(nextFrontmatter, existing.task.description);
                 if (event.to === "archived") {
-                    const targetPath = archivedTaskPath(deps.path, list, id);
+                    const targetPath = archivedTaskPath(deps.path, layout, list, id);
                     const archivedTargetExists = await statIfExists(deps.fs, targetPath);
                     if (archivedTargetExists?.isFile()) {
                         throw new TaskAlreadyExistsError(`Task "${list}/${id}" already exists in archive.`);
                     }
                     await writeAtomically(deps.fs, existing.path, serializedTask);
-                    await deps.fs.mkdir(archiveDirectoryPath(deps.path, list), { recursive: true });
+                    await deps.fs.mkdir(archiveDirectoryPath(deps.path, layout, list), { recursive: true });
                     await deps.fs.rename(existing.path, targetPath);
                     await event.onEnter?.(nextTask);
                     return nextTask;
@@ -515,7 +658,18 @@ function createTasksView(deps, list) {
                 await writeAtomically(deps.fs, existing.path, serializedTask);
                 await event.onEnter?.(nextTask);
                 return nextTask;
-            });
+            };
+            if (stateMachine.events[eventName]?.to === "archived") {
+                validateTaskId(id);
+                return withListLock(async () => {
+                    const location = await findTaskLocation(deps.fs, deps.path, layout, list, id);
+                    if (!location) {
+                        throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+                    }
+                    return withLocatedTaskLock(location, fireTask);
+                });
+            }
+            return withTaskLock(id, fireTask);
         },
         async canFire(id, eventName) {
             const task = (await getTaskFile(id)).task;
@@ -531,7 +685,7 @@ function createTasksView(deps, list) {
         },
         async delete(id) {
             await withTaskLock(id, async () => {
-                const location = await findTaskLocation(deps.fs, deps.path, list, id);
+                const location = await findTaskLocation(deps.fs, deps.path, layout, list, id);
                 if (!location) {
                     throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
                 }
@@ -561,7 +715,7 @@ function createTasksView(deps, list) {
                     insertIndex = "before" in anchor ? anchorIndex : anchorIndex + 1;
                 }
                 ordered.splice(insertIndex, 0, id);
-                await rewriteListPrefixes(ordered);
+                await rewriteMovedPrefix(id, ordered);
                 return tasks.get(id).task;
             });
         },
@@ -587,13 +741,23 @@ function createTasksView(deps, list) {
 }
 export async function markdownDirBackend(deps) {
     await ensureRootPath(deps);
+    const layout = resolveListLayout(deps);
     const stateMachine = resolveStateMachine(deps.stateMachine);
     const validStates = new Set(stateMachine.states);
     const list = (name) => {
+        if (layout.kind === "single") {
+            if (name !== layout.name) {
+                throw new Error(`Task list "${name}" not found.`);
+            }
+            return createTasksView(deps, layout, name);
+        }
         const listName = validateListName(name);
-        return createTasksView(deps, listName);
+        return createTasksView(deps, layout, listName);
     };
     const lists = async () => {
+        if (layout.kind === "single") {
+            return [layout.name];
+        }
         const entries = await readDirectoryNames(deps.fs, deps.path);
         const result = [];
         for (const entryName of entries) {
@@ -623,21 +787,24 @@ export async function markdownDirBackend(deps) {
         return list(listName).get(id);
     };
     const moveBetweenLists = async (qualifiedId, targetList) => {
+        if (layout.kind === "single") {
+            throw new Error("moveBetweenLists is unsupported in single-list mode.");
+        }
         const { list: sourceListName, id } = parseQualifiedId(qualifiedId);
         const targetListName = validateListName(targetList);
         if (sourceListName === targetListName) {
-            const file = await readTaskAtLocation(deps.fs, deps.path, sourceListName, id, validStates);
+            const file = await readTaskAtLocation(deps.fs, deps.path, layout, sourceListName, id, validStates, stateMachine.initial, deps.frontmatterMode);
             return file.task;
         }
-        const targetExisting = await findTaskLocation(deps.fs, deps.path, targetListName, id);
+        const targetExisting = await findTaskLocation(deps.fs, deps.path, layout, targetListName, id);
         if (targetExisting) {
             throw new TaskAlreadyExistsError(`Task "${targetListName}/${id}" already exists.`);
         }
-        const sourceLocation = await findTaskLocation(deps.fs, deps.path, sourceListName, id);
+        const sourceLocation = await findTaskLocation(deps.fs, deps.path, layout, sourceListName, id);
         if (!sourceLocation) {
             throw new TaskNotFoundError(`Task "${sourceListName}/${id}" not found.`);
         }
-        const targetListDir = listPath(deps.path, targetListName);
+        const targetListDir = listPath(deps.path, layout, targetListName);
         await deps.fs.mkdir(targetListDir, { recursive: true });
         const targetEntries = await (async () => {
             const out = [];
@@ -653,11 +820,11 @@ export async function markdownDirBackend(deps) {
             return out;
         })();
         if (sourceLocation.archived) {
-            const archivedTargetDir = archiveDirectoryPath(deps.path, targetListName);
+            const archivedTargetDir = archiveDirectoryPath(deps.path, layout, targetListName);
             await deps.fs.mkdir(archivedTargetDir, { recursive: true });
-            const archivedTargetPath = archivedTaskPath(deps.path, targetListName, id);
+            const archivedTargetPath = archivedTaskPath(deps.path, layout, targetListName, id);
             await deps.fs.rename(sourceLocation.path, archivedTargetPath);
-            const file = await readTaskFile(deps.fs, targetListName, id, archivedTargetPath, validStates);
+            const file = await readTaskFile(deps.fs, targetListName, id, archivedTargetPath, validStates, stateMachine.initial, deps.frontmatterMode);
             return file.task;
         }
         const maxOrder = targetEntries.reduce((max, entry) => (entry.order !== null && entry.order > max ? entry.order : max), 0);
@@ -665,7 +832,7 @@ export async function markdownDirBackend(deps) {
         const targetFilename = activeTaskFilename(id, maxOrder + 1, width);
         const targetPath = path.join(targetListDir, targetFilename);
         await deps.fs.rename(sourceLocation.path, targetPath);
-        const file = await readTaskFile(deps.fs, targetListName, id, targetPath, validStates);
+        const file = await readTaskFile(deps.fs, targetListName, id, targetPath, validStates, stateMachine.initial, deps.frontmatterMode);
         return file.task;
     };
     return {

package/node_modules/@poe-code/task-list/dist/index.d.ts

@@ -4,3 +4,4 @@ export { eventsFromState, findEvent, validateMachine, type EventDef, type StateM
 export { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError, type ListFilter, type MoveAnchor, type OpenGhIssuesOptions, type OpenMarkdownDirOptions, type OpenTaskListOptions, type OpenYamlFileOptions, type Task, type TaskCreate, type TaskDefaults, type TaskFireOptions, type TaskList, type TaskListFs, type TaskOrder, type TaskState, type Tasks, type TaskUpdate } from "./types.js";
 export type { GhClient, GhClientOptions, ResolveAuthOptions, ResolveEndpointOptions } from "./backends/gh-issues-client.js";
 export type { GhIssuesBackendDeps } from "./backends/gh-issues.js";
+export { GhProjectSyncError, syncGhProject, verifyGhProject, type SyncGhProjectOptions, type SyncGhProjectReport, type VerifyGhProjectOptions, type VerifyGhProjectReport } from "./backends/gh-issues-sync.js";

package/node_modules/@poe-code/task-list/dist/index.js

@@ -2,3 +2,4 @@ export { openTaskList } from "./open.js";
 export { assertEvent, assertTransition, defaultStateMachine } from "./state.js";
 export { eventsFromState, findEvent, validateMachine } from "./state-machine.js";
 export { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError } from "./types.js";
+export { GhProjectSyncError, syncGhProject, verifyGhProject } from "./backends/gh-issues-sync.js";

package/node_modules/@poe-code/task-list/dist/open.js

@@ -29,11 +29,14 @@ async function openFileBackend(options) {
     const factory = backendFactories[options.type];
     const stateMachine = resolveStateMachine(options.stateMachine);
     validateMachine(stateMachine);
+    const markdownOptions = options.type === "markdown-dir" ? options : undefined;
     const deps = {
         path: options.path,
         defaults: {
             metadata: { ...(options.defaults?.metadata ?? {}) }
         },
+        singleList: markdownOptions?.singleList,
+        frontmatterMode: markdownOptions?.frontmatterMode ?? "strict",
         lockStaleMs: options.lockStaleMs ?? DEFAULT_LOCK_STALE_MS,
         lockRetries: options.lockRetries ?? DEFAULT_LOCK_RETRIES,
         create: options.create ?? false,

package/node_modules/@poe-code/task-list/dist/types.d.ts

@@ -91,6 +91,8 @@ export interface OpenMarkdownDirOptions {
     path: string;
     defaults?: TaskDefaults;
     create?: boolean;
+    singleList?: string;
+    frontmatterMode?: "strict" | "passthrough";
     lockStaleMs?: number;
     lockRetries?: number;
     fs?: TaskListFs;
@@ -122,6 +124,8 @@ export interface OpenGhIssuesOptions {
 export interface BackendDeps {
     path: string;
     defaults: Required<TaskDefaults>;
+    singleList?: string;
+    frontmatterMode: "strict" | "passthrough";
     lockStaleMs: number;
     lockRetries: number;
     create: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,7 +49,7 @@
     "mustache": "^4.2.0",
     "smol-toml": "^1.3.0",
     "tiny-stdio-mcp-server": "^0.1.0",
-    "toolcraft-schema": "^0.0.15",
+    "toolcraft-schema": "^0.0.17",
     "yaml": "^2.8.2"
   },
   "files": [
@@ -81,7 +81,7 @@
     "@poe-code/agent-human-in-loop": "*",
     "@poe-code/agent-mcp-config": "*",
     "@poe-code/config-mutations": "*",
-    "@poe-code/design-system": "^0.0.1",
+    "@poe-code/design-system": "^0.0.2",
     "@poe-code/file-lock": "*",
     "@poe-code/process-runner": "*",
     "@poe-code/task-list": "*",