toolcraft 0.0.50 → 0.0.52

package/node_modules/@poe-code/process-runner/dist/docker/args.js

@@ -36,7 +36,8 @@ export function buildDockerRunArgs(input) {
         const volume = `${path.resolve(mount.source)}:${mount.target}${mount.readonly ? ":ro" : ""}`;
         args.push("-v", volume);
     }
-    for (const port of input.ports) {
+    for (const [index, port] of input.ports.entries()) {
+        assertValidDockerPortMapping(port, index);
         const mapping = `${port.host}:${port.container}${port.protocol === undefined || port.protocol === "tcp" ? "" : `/${port.protocol}`}`;
         args.push("-p", mapping);
     }
@@ -46,3 +47,15 @@ export function buildDockerRunArgs(input) {
     args.push(...input.extraArgs, input.image, input.command, ...input.args);
     return args;
 }
+function assertValidDockerPortMapping(port, index) {
+    assertValidPortNumber(port.host, `ports[${index}].host`);
+    assertValidPortNumber(port.container, `ports[${index}].container`);
+    if (port.protocol !== undefined && port.protocol !== "tcp" && port.protocol !== "udp") {
+        throw new Error(`Invalid Docker port mapping ${index}: protocol must be tcp or udp.`);
+    }
+}
+function assertValidPortNumber(value, field) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > 65_535) {
+        throw new Error(`Invalid Docker port mapping ${field}: port must be an integer from 1 to 65535.`);
+    }
+}

package/node_modules/@poe-code/process-runner/dist/docker/build-context.d.ts

@@ -0,0 +1,5 @@
+export interface DockerBuildContextFile {
+    relativePath: string;
+    bytes: Buffer;
+}
+export declare function readDockerBuildContextFiles(buildContext: string): Promise<DockerBuildContextFile[]>;

package/node_modules/@poe-code/process-runner/dist/docker/build-context.js

@@ -0,0 +1,37 @@
+import { readdir, readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+const require = createRequire(import.meta.url);
+const createIgnore = require("ignore");
+export async function readDockerBuildContextFiles(buildContext) {
+    const rootEntries = await readdir(buildContext, { withFileTypes: true });
+    const dockerignoreEntry = rootEntries.find((entry) => entry.isFile() && String(entry.name) === ".dockerignore");
+    const ignored = createIgnore();
+    if (dockerignoreEntry !== undefined) {
+        ignored.add(String(await readFile(path.join(buildContext, ".dockerignore"))));
+    }
+    const files = [];
+    await collectBuildContextFiles(buildContext, "", files, ignored, rootEntries);
+    return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+async function collectBuildContextFiles(buildContext, relativeDir, files, ignored, entries) {
+    const absoluteDir = path.join(buildContext, relativeDir);
+    const dirEntries = entries ?? (await readdir(absoluteDir, { withFileTypes: true }));
+    for (const entry of dirEntries) {
+        const relativePath = path.join(relativeDir, String(entry.name));
+        const dockerPath = relativePath.split(path.sep).join("/");
+        if (entry.isDirectory()) {
+            if (!ignored.ignores(`${dockerPath}/`)) {
+                await collectBuildContextFiles(buildContext, relativePath, files, ignored);
+            }
+            continue;
+        }
+        if (!entry.isFile() || (dockerPath !== ".dockerignore" && ignored.ignores(dockerPath))) {
+            continue;
+        }
+        files.push({
+            relativePath: dockerPath,
+            bytes: await readFile(path.join(buildContext, relativePath))
+        });
+    }
+}

package/node_modules/@poe-code/process-runner/dist/docker/docker-execution-env.js

@@ -1,9 +1,10 @@
 import { createHash, randomBytes } from "node:crypto";
 import { mkdtempSync, rmSync } from "node:fs";
-import { readdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { readFile, realpath, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { buildDockerEnvArgs, buildDockerRunArgs } from "./args.js";
+import { readDockerBuildContextFiles } from "./build-context.js";
 import { buildContextArgs, detectContext } from "./context.js";
 import { detectEngine } from "./engine.js";
 import { createDockerEnvFile } from "./env-file.js";
@@ -185,7 +186,7 @@ export async function buildDockerRuntimeTemplate(input) {
     const context = detectContext();
     const { dockerfilePath, buildContext } = await resolveRuntimeBuildPaths(input.cwd, input.runtime);
     const dockerfileBytes = await readFile(dockerfilePath);
-    const buildContextFiles = await readBuildContextFiles(buildContext);
+    const buildContextFiles = await readDockerBuildContextFiles(buildContext);
     const hash = hashDockerTemplate(dockerfileBytes, buildContextFiles, input.runtime.build_args ?? {}, engine);
     const cached = input.force ? null : await input.state?.templates.get("docker", hash);
     if (cached?.image !== undefined && (await imageExists(runner, engine, context, cached.image))) {
@@ -262,29 +263,6 @@ function hashDockerTemplate(dockerfileBytes, buildContextFiles, buildArgs, engin
     }
     return hash.digest("hex");
 }
-async function readBuildContextFiles(buildContext) {
-    const files = [];
-    await collectBuildContextFiles(buildContext, "", files);
-    return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
-}
-async function collectBuildContextFiles(buildContext, relativeDir, files) {
-    const absoluteDir = path.join(buildContext, relativeDir);
-    const entries = await readdir(absoluteDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const relativePath = path.join(relativeDir, entry.name);
-        if (entry.isDirectory()) {
-            await collectBuildContextFiles(buildContext, relativePath, files);
-            continue;
-        }
-        if (!entry.isFile()) {
-            continue;
-        }
-        files.push({
-            relativePath: relativePath.split(path.sep).join("/"),
-            bytes: await readFile(path.join(buildContext, relativePath))
-        });
-    }
-}
 async function imageExists(runner, engine, context, image) {
     const handle = runner.exec({
         command: engine,
@@ -602,8 +580,7 @@ function createContainerJob(containerId, runner, engine, context, detachedJobCon
             });
             const stdout = await readStream(handle.stdout);
             const result = await handle.result;
-            const exitCode = Number.parseInt(stdout.trim(), 10);
-            return { exitCode: Number.isNaN(exitCode) ? result.exitCode : exitCode };
+            return { exitCode: parseDockerWaitExitCode(stdout, result.exitCode) };
         },
         async kill(signal) {
             const args = signal === undefined || signal === "SIGTERM"
@@ -618,6 +595,29 @@ function createContainerJob(containerId, runner, engine, context, detachedJobCon
         }
     };
 }
+function parseDockerWaitExitCode(stdout, fallbackExitCode) {
+    const trimmed = stdout.trim();
+    if (trimmed.length === 0) {
+        return fallbackExitCode;
+    }
+    return parseCompleteDecimalExitCode(trimmed, "docker wait");
+}
+function parseCompleteDecimalExitCode(value, source) {
+    if (value.length === 0) {
+        throw new Error(`${source} returned an invalid exit code: ${JSON.stringify(value)}.`);
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code < 48 || code > 57) {
+            throw new Error(`${source} returned an invalid exit code: ${JSON.stringify(value)}.`);
+        }
+    }
+    const exitCode = Number(value);
+    if (!Number.isSafeInteger(exitCode)) {
+        throw new Error(`${source} returned an invalid exit code: ${JSON.stringify(value)}.`);
+    }
+    return exitCode;
+}
 function completeUtf8PrefixLength(contents) {
     if (contents.length === 0) {
         return 0;
@@ -671,8 +671,8 @@ async function readDetachedExitCode(containerId, jobId, runner, engine, context)
     if (result.exitCode !== 0) {
         return null;
     }
-    const exitCode = Number.parseInt(stdout.trim(), 10);
-    return Number.isNaN(exitCode) ? null : exitCode;
+    const text = stdout.trim();
+    return text.length === 0 ? null : parseCompleteDecimalExitCode(text, "detached exit marker");
 }
 function createAttachedSpec(cwd = "/workspace") {
     return {

package/node_modules/@poe-code/process-runner/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { buildContextArgs, detectContext } from "./docker/context.js";
+export { readDockerBuildContextFiles, type DockerBuildContextFile } from "./docker/build-context.js";
 export { detectEngine, isEngineAvailable } from "./docker/engine.js";
 export { createDockerRunner } from "./docker/docker-runner.js";
 export { buildDockerRuntimeTemplate, dockerExecutionEnvFactory } from "./docker/docker-execution-env.js";

package/node_modules/@poe-code/process-runner/dist/index.js

@@ -1,4 +1,5 @@
 export { buildContextArgs, detectContext } from "./docker/context.js";
+export { readDockerBuildContextFiles } from "./docker/build-context.js";
 export { detectEngine, isEngineAvailable } from "./docker/engine.js";
 export { createDockerRunner } from "./docker/docker-runner.js";
 export { buildDockerRuntimeTemplate, dockerExecutionEnvFactory } from "./docker/docker-execution-env.js";

package/node_modules/@poe-code/process-runner/dist/workspace-transfer.js

@@ -6,13 +6,13 @@ export async function uploadWorkspace(env, opts) {
     const localFs = env.fs ?? nodeFs;
     const remoteFs = env.remoteFs ?? localFs;
     const workspaceDir = env.workspaceDir ?? "/workspace";
-    const maxBytes = (opts.uploadMaxFileMb ?? opts.runner?.upload_max_file_mb ?? 100) * 1024 * 1024;
+    const maxBytes = resolveUploadMaxBytes(opts);
     const warn = opts.warn ?? console.warn;
     const allFiles = await listFiles(localFs, env.cwd);
     const state = new Map();
     const gitignore = await readGitignoreRules(localFs, env.cwd, allFiles);
     const poeCodeIgnore = await readIgnoreFile(localFs, env.cwd, ".poe-code-ignore", false);
-    const workspaceExclude = parseIgnoreLines([...(opts.runner?.workspace?.exclude ?? []), ...(opts.workspaceExclude ?? [])], false);
+    const workspaceExclude = parseIgnoreLines([".git/", ...(opts.runner?.workspace?.exclude ?? []), ...(opts.workspaceExclude ?? [])], false);
     const entries = [];
     const skipped = [];
     for (const file of allFiles) {
@@ -122,6 +122,13 @@ export async function downloadWorkspace(env, opts) {
     }
     return { files, bytes, conflicts };
 }
+function resolveUploadMaxBytes(opts) {
+    const uploadMaxFileMb = opts.uploadMaxFileMb ?? opts.runner?.upload_max_file_mb ?? 100;
+    if (!Number.isFinite(uploadMaxFileMb) || uploadMaxFileMb <= 0) {
+        throw new Error("runner.upload_max_file_mb must be a finite positive number.");
+    }
+    return uploadMaxFileMb * 1024 * 1024;
+}
 async function listFilesIfExists(fs, root, options = {}) {
     try {
         return await listFiles(fs, root, options);
@@ -205,17 +212,50 @@ function parseIgnoreLines(lines, allowNegation, basePath = "") {
     return rules;
 }
 function isIgnoredByGit(relativePath, rules) {
+    if (isPathIgnoredByGitRules(relativePath, rules, "path")) {
+        return true;
+    }
+    for (const parent of parentDirectories(relativePath)) {
+        if (isPathIgnoredByGitRules(parent, rules, "directory")) {
+            return true;
+        }
+    }
+    return false;
+}
+function isPathIgnoredByGitRules(relativePath, rules, targetKind) {
     let ignored = false;
     for (const rule of rules) {
-        if (matchesRule(relativePath, rule)) {
+        if (matchesGitRule(relativePath, rule, targetKind)) {
             ignored = !rule.negate;
         }
     }
     return ignored;
 }
+function parentDirectories(relativePath) {
+    const segments = normalizeRelativePath(relativePath).split("/");
+    const parents = [];
+    for (let index = 1; index < segments.length; index += 1) {
+        parents.push(segments.slice(0, index).join("/"));
+    }
+    return parents;
+}
 function isIgnoredAdditively(relativePath, rules) {
     return rules.some((rule) => matchesRule(relativePath, rule));
 }
+function matchesGitRule(relativePath, rule, targetKind) {
+    if (!rule.directoryOnly) {
+        return matchesRule(relativePath, rule);
+    }
+    const normalizedPath = normalizeRelativePath(relativePath);
+    const scopedPath = pathWithinRuleScope(normalizedPath, rule.basePath);
+    if (scopedPath === null) {
+        return false;
+    }
+    if (targetKind === "directory") {
+        return pathMatchesDirectorySelf(scopedPath, normalizeRelativePath(rule.pattern), rule.anchored);
+    }
+    return !rule.negate && matchesRule(relativePath, rule);
+}
 function matchesRule(relativePath, rule) {
     const normalizedPath = normalizeRelativePath(relativePath);
     const scopedPath = pathWithinRuleScope(normalizedPath, rule.basePath);
@@ -250,6 +290,12 @@ function pathMatchesDirectory(relativePath, pattern, anchored) {
         return matchSegment(segment, pattern) && index < segments.length - 1;
     });
 }
+function pathMatchesDirectorySelf(relativePath, pattern, anchored) {
+    if (anchored || pattern.includes("/")) {
+        return relativePath === pattern;
+    }
+    return relativePath.split("/").some((segment) => matchSegment(segment, pattern));
+}
 function matchPathSegments(pathSegments, patternSegments) {
     return matchPathFrom(0, 0);
     function matchPathFrom(pathIndex, patternIndex) {

package/node_modules/@poe-code/process-runner/package.json

@@ -10,6 +10,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./docker/build-context": {
+      "types": "./dist/docker/build-context.d.ts",
+      "import": "./dist/docker/build-context.js"
+    },
     "./testing": {
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.js"
@@ -23,5 +27,8 @@
   },
   "files": [
     "dist"
-  ]
+  ],
+  "dependencies": {
+    "ignore": "^5.3.2"
+  }
 }

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

@@ -51,6 +51,7 @@ export class GhProjectSyncError extends Error {
     }
 }
 export async function verifyGhProject(opts) {
+    validateRequiredStates(opts.requiredStates);
     const client = resolveGhClient(opts);
     const lookup = await lookupProject(client, opts.owner, opts.number);
     return buildVerifyReport(lookup, opts);
@@ -124,6 +125,7 @@ function buildVerifyReport(lookup, opts) {
     };
 }
 export async function syncGhProject(opts) {
+    validateRequiredStates(opts.requiredStates);
     const client = resolveGhClient(opts);
     let lookup = await lookupProject(client, opts.owner, opts.number);
     const initialReport = buildVerifyReport(lookup, opts);
@@ -184,6 +186,11 @@ export async function syncGhProject(opts) {
         updated: []
     };
 }
+function validateRequiredStates(requiredStates) {
+    if (requiredStates.some((state) => state.trim().length === 0)) {
+        throw new Error("requiredStates must not contain empty state names.");
+    }
+}
 async function createProject(client, opts) {
     const target = `${opts.owner}/${opts.number}`;
     try {

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

@@ -1,4 +1,4 @@
-import { eventsFromState, findEvent } from "../state-machine.js";
+import { eventsFromState, findEvent, validateMachine } 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";
@@ -251,6 +251,9 @@ export async function ghIssuesBackend(deps) {
     if (deps.state?.labelPrefix === "") {
         throw new Error("gh-issues state.labelPrefix must be a non-empty string when configured.");
     }
+    if (deps.stateMachine !== undefined) {
+        validateMachine(deps.stateMachine);
+    }
     const client = createGhClient({
         token: deps.token,
         endpoint: deps.endpoint,
@@ -446,7 +449,9 @@ function createTasksView(name, session, context) {
                 listName: name,
                 session
             });
-            return session.labelPrefix === undefined ? task : { ...task, state: session.stateMachine.initial };
+            return session.labelPrefix === undefined
+                ? task
+                : { ...task, state: session.stateMachine.initial };
         },
         async update(id, patch) {
             const task = await fetchIssueTask(id, name, session, context);
@@ -646,7 +651,9 @@ async function resolveProjectItemId(id, listName, session, context) {
             return projectItem.id;
         }
         const pageInfo = issue.projectItems?.pageInfo;
-        if (pageInfo?.hasNextPage !== true || pageInfo.endCursor === undefined || pageInfo.endCursor === null) {
+        if (pageInfo?.hasNextPage !== true ||
+            pageInfo.endCursor === undefined ||
+            pageInfo.endCursor === null) {
             throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
         }
         after = pageInfo.endCursor;
@@ -711,7 +718,9 @@ async function updateIssueStateLabel(id, listName, state, session, context) {
             break;
         }
         const pageInfo = currentIssue.projectItems?.pageInfo;
-        if (pageInfo?.hasNextPage !== true || pageInfo.endCursor === undefined || pageInfo.endCursor === null) {
+        if (pageInfo?.hasNextPage !== true ||
+            pageInfo.endCursor === undefined ||
+            pageInfo.endCursor === null) {
             break;
         }
         after = pageInfo.endCursor;
@@ -883,12 +892,15 @@ async function fetchIssueTask(id, listName, session, context) {
             break;
         }
         projectItem =
-            currentIssue.projectItems?.nodes?.find((item) => item.project?.id === session.projectId) ?? null;
+            currentIssue.projectItems?.nodes?.find((item) => item.project?.id === session.projectId) ??
+                null;
         if (projectItem !== null) {
             break;
         }
         const pageInfo = currentIssue.projectItems?.pageInfo;
-        if (pageInfo?.hasNextPage !== true || pageInfo.endCursor === undefined || pageInfo.endCursor === null) {
+        if (pageInfo?.hasNextPage !== true ||
+            pageInfo.endCursor === undefined ||
+            pageInfo.endCursor === null) {
             throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
         }
         after = pageInfo.endCursor;
@@ -902,12 +914,27 @@ async function fetchIssueTask(id, listName, session, context) {
     });
 }
 function parseIssueNumber(id, listName) {
+    if (!isCanonicalDecimalIssueId(id)) {
+        throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+    }
     const issueNumber = Number(id);
-    if (!Number.isInteger(issueNumber) || issueNumber < 1) {
+    if (!Number.isSafeInteger(issueNumber) || issueNumber < 1) {
         throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
     }
     return issueNumber;
 }
+function isCanonicalDecimalIssueId(id) {
+    if (id.length === 0 || id[0] === "0") {
+        return false;
+    }
+    for (let index = 0; index < id.length; index += 1) {
+        const charCode = id.charCodeAt(index);
+        if (charCode < 48 || charCode > 57) {
+            return false;
+        }
+    }
+    return true;
+}
 function mapProjectItemToTask(item, listName, session) {
     const content = item.content;
     if (!isIssueNode(content)) {

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

@@ -4,7 +4,7 @@ import taskSchema from "../schema/task.schema.json" with { type: "json" };
 import { eventsFromState, findEvent } from "../state-machine.js";
 import { resolveStateMachine } from "../state.js";
 import { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError } from "../types.js";
-import { applyOrder, hasErrorCode, isRecord, rejectSymbolicLinkComponents, sortStrings, statIfExists, validateTaskId, withFileLock, writeAtomically } from "./utils.js";
+import { applyOrder, hasErrorCode, isTrimmedPrintableIdentifier, isRecord, rejectSymbolicLinkComponents, sortStrings, statIfExists, validateTaskId, validateTaskName, withFileLock, writeAtomically } from "./utils.js";
 const ARCHIVE_DIRECTORY_NAME = "archive";
 const MARKDOWN_EXTENSION = ".md";
 const TASK_KIND = "task";
@@ -25,7 +25,7 @@ function resolveListLayout(deps) {
     return deps.singleList ? { kind: "single", name: deps.singleList } : { kind: "multi" };
 }
 function validateListName(name) {
-    if (name.length === 0 ||
+    if (!isTrimmedPrintableIdentifier(name) ||
         name === ARCHIVE_DIRECTORY_NAME ||
         name.startsWith(".") ||
         name.includes("/") ||
@@ -239,11 +239,9 @@ async function readTaskFile(fs, list, id, filePath, validStates, initialState, m
             task: createTask(list, id, frontmatter, document.body, mode, filePath)
         };
     }
-    const parsedFilename = parseActiveFilename(path.basename(filePath));
-    const defaultName = parsedFilename?.id ?? id;
     const effectiveFrontmatter = {
         ...frontmatter,
-        name: typeof frontmatter.name === "string" ? frontmatter.name : defaultName,
+        name: typeof frontmatter.name === "string" ? frontmatter.name : id,
         state: typeof frontmatter.state === "string" && validStates.has(frontmatter.state)
             ? frontmatter.state
             : initialState
@@ -254,22 +252,72 @@ async function readTaskFile(fs, list, id, filePath, validStates, initialState, m
         task: createTask(list, id, effectiveFrontmatter, document.body, mode, filePath)
     };
 }
-async function findActiveTaskFilename(fs, listDirectoryPath, id) {
+async function readPassthroughFrontmatter(fs, filePath, mode) {
+    if (mode !== "passthrough") {
+        return {};
+    }
+    const content = await fs.readFile(filePath, "utf8");
+    const document = splitTaskDocument(content, filePath, mode);
+    if (document.frontmatter.trim().length === 0) {
+        return {};
+    }
+    return readFrontmatter(document.frontmatter, filePath);
+}
+async function resolveActiveFilenameEntry(fs, entryName, entryPath, parsed, mode) {
+    if (mode !== "passthrough" || parsed.order === null) {
+        return parsed;
+    }
+    const frontmatter = await readPassthroughFrontmatter(fs, entryPath, mode);
+    if (Object.keys(frontmatter).length === 0 &&
+        orderedFilenamePrefixLength(entryName) <= MIN_PREFIX_WIDTH) {
+        return parsed;
+    }
+    if (typeof frontmatter.state === "string" ||
+        hasOwnTaskField(frontmatter, "$schema") ||
+        hasOwnTaskField(frontmatter, "kind") ||
+        hasOwnTaskField(frontmatter, "version")) {
+        return parsed;
+    }
+    return {
+        id: entryName.slice(0, -MARKDOWN_EXTENSION.length),
+        order: null,
+        filename: parsed.filename
+    };
+}
+function orderedFilenamePrefixLength(entryName) {
+    const stem = entryName.slice(0, -MARKDOWN_EXTENSION.length);
+    const separatorIndex = stem.indexOf("-");
+    if (separatorIndex <= 0) {
+        return Number.POSITIVE_INFINITY;
+    }
+    for (let index = 0; index < separatorIndex; index += 1) {
+        const code = stem.charCodeAt(index);
+        if (code < 48 || code > 57) {
+            return Number.POSITIVE_INFINITY;
+        }
+    }
+    return separatorIndex;
+}
+async function findActiveTaskFilename(fs, listDirectoryPath, id, mode) {
     const entries = await readDirectoryNames(fs, listDirectoryPath);
     for (const entryName of entries) {
         if (isHiddenEntry(entryName))
             continue;
         const parsed = parseActiveFilename(entryName);
-        if (parsed?.id === id) {
+        if (!parsed)
+            continue;
+        const entryPath = path.join(listDirectoryPath, entryName);
+        const resolved = await resolveActiveFilenameEntry(fs, entryName, entryPath, { id: parsed.id, order: parsed.order, filename: entryName }, mode);
+        if (resolved.id === id) {
             return entryName;
         }
     }
     return undefined;
 }
-async function findTaskLocation(fs, rootPath, layout, list, id) {
+async function findTaskLocation(fs, rootPath, layout, list, id, mode) {
     const listDirectoryPath = listPath(rootPath, layout, list);
     await rejectSymbolicLinkComponents(fs, listDirectoryPath);
-    const activeName = await findActiveTaskFilename(fs, listDirectoryPath, id);
+    const activeName = await findActiveTaskFilename(fs, listDirectoryPath, id, mode);
     if (activeName) {
         const activePath = path.join(listDirectoryPath, activeName);
         await rejectSymbolicLinkComponents(fs, activePath);
@@ -288,7 +336,7 @@ async function findTaskLocation(fs, rootPath, layout, list, id) {
     return undefined;
 }
 async function readTaskAtLocation(fs, rootPath, layout, list, id, validStates, initialState, mode) {
-    const location = await findTaskLocation(fs, rootPath, layout, list, id);
+    const location = await findTaskLocation(fs, rootPath, layout, list, id, mode);
     if (!location) {
         throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
     }
@@ -404,7 +452,7 @@ function createTasksView(deps, layout, list) {
             const entryStat = await statIfExists(deps.fs, entryPath);
             if (!entryStat?.isFile())
                 continue;
-            result.push({ id: parsed.id, order: parsed.order, filename: entryName });
+            result.push(await resolveActiveFilenameEntry(deps.fs, entryName, entryPath, { id: parsed.id, order: parsed.order, filename: entryName }, deps.frontmatterMode));
         }
         result.sort((left, right) => {
             const leftOrder = left.order ?? Number.POSITIVE_INFINITY;
@@ -460,7 +508,12 @@ function createTasksView(deps, layout, list) {
                 const targetPath = path.join(listDirectoryPath, desiredFilename);
                 try {
                     await deps.fs.rename(fromPath, stagingPath);
-                    staged.push({ original: fromPath, staging: stagingPath, target: targetPath, finalized: false });
+                    staged.push({
+                        original: fromPath,
+                        staging: stagingPath,
+                        target: targetPath,
+                        finalized: false
+                    });
                 }
                 catch (error) {
                     for (const stagedEntry of staged.reverse()) {
@@ -598,8 +651,7 @@ function createTasksView(deps, layout, list) {
                     return false;
                 return true;
             });
-            const orderedActiveTasks = applyOrder(orderedActive, filter?.order);
-            return [...orderedActiveTasks, ...filteredArchived.map((entry) => entry.task)];
+            return applyOrder([...orderedActive, ...filteredArchived], filter?.order);
         },
         async get(id) {
             return (await getTaskFile(id)).task;
@@ -608,9 +660,10 @@ function createTasksView(deps, layout, list) {
             assertCreateDoesNotSetState(input);
             assertCreateHasId(input);
             validateTaskId(input.id);
+            validateTaskName(input.name);
             await rejectSymbolicLinkComponents(deps.fs, listDirectoryPath);
             return withFileLock(deps.fs, path.join(listDirectoryPath, ".transition.lock"), async () => {
-                const existing = await findTaskLocation(deps.fs, deps.path, layout, list, input.id);
+                const existing = await findTaskLocation(deps.fs, deps.path, layout, list, input.id, deps.frontmatterMode);
                 if (existing) {
                     throw new TaskAlreadyExistsError(`Task "${list}/${input.id}" already exists.`);
                 }
@@ -629,6 +682,9 @@ function createTasksView(deps, layout, list) {
         async update(id, patch) {
             assertUpdateDoesNotSetState(patch);
             validateTaskId(id);
+            if (patch.name !== undefined) {
+                validateTaskName(patch.name);
+            }
             const existing = await getTaskFile(id);
             const nextFrontmatter = updatedFrontmatter(existing.frontmatter, existing.task, patch, deps.frontmatterMode);
             const description = patch.description ?? existing.task.description;
@@ -676,7 +732,7 @@ function createTasksView(deps, layout, list) {
             };
             if (stateMachine.events[eventName]?.to === "archived") {
                 validateTaskId(id);
-                const location = await findTaskLocation(deps.fs, deps.path, layout, list, id);
+                const location = await findTaskLocation(deps.fs, deps.path, layout, list, id, deps.frontmatterMode);
                 if (!location) {
                     throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
                 }
@@ -700,7 +756,7 @@ function createTasksView(deps, layout, list) {
         },
         async delete(id) {
             validateTaskId(id);
-            const location = await findTaskLocation(deps.fs, deps.path, layout, list, id);
+            const location = await findTaskLocation(deps.fs, deps.path, layout, list, id, deps.frontmatterMode);
             if (!location) {
                 throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
             }
@@ -808,11 +864,11 @@ export async function markdownDirBackend(deps) {
         const targetListDir = listPath(deps.path, layout, targetListName);
         await rejectSymbolicLinkComponents(deps.fs, targetListDir);
         return withFileLock(deps.fs, path.join(targetListDir, ".transition.lock"), async () => {
-            const targetExisting = await findTaskLocation(deps.fs, deps.path, layout, targetListName, id);
+            const targetExisting = await findTaskLocation(deps.fs, deps.path, layout, targetListName, id, deps.frontmatterMode);
             if (targetExisting) {
                 throw new TaskAlreadyExistsError(`Task "${targetListName}/${id}" already exists.`);
             }
-            const sourceLocation = await findTaskLocation(deps.fs, deps.path, layout, sourceListName, id);
+            const sourceLocation = await findTaskLocation(deps.fs, deps.path, layout, sourceListName, id, deps.frontmatterMode);
             if (!sourceLocation) {
                 throw new TaskNotFoundError(`Task "${sourceListName}/${id}" not found.`);
             }

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

@@ -9,7 +9,9 @@ export declare function hasErrorCode(error: unknown, code: string): boolean;
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function sortStrings(values: string[]): string[];
 export declare function sortTasks(tasks: Task[]): Task[];
+export declare function isTrimmedPrintableIdentifier(value: string): boolean;
 export declare function validateTaskId(id: string): string;
+export declare function validateTaskName(name: string): string;
 export declare function statIfExists(fs: TaskListFs, filePath: string): Promise<Awaited<ReturnType<TaskListFs["stat"]>> | undefined>;
 export declare function rejectSymbolicLinkComponents(fs: TaskListFs, filePath: string): Promise<void>;
 export declare function writeAtomically(fs: TaskListFs, filePath: string, content: string): Promise<void>;