@astrosheep/keiyaku 4.5.6 → 4.5.7

package/build/src/cli/commands/task-invoke.js

@@ -1,4 +1,6 @@
+/* eslint-disable max-lines -- Task edge keeps native reads, forwarding, and local dispatch together. */
 import { Tasks, } from "../../task/index.js";
+import { taskCompositionNamespaceHeader } from "../../task/compose-language.js";
 import { observeTaskDetails } from "../../task/operations.js";
 import { injectedBodyRequests, requestBodyTask } from "../../akuma/requests.js";
 import { decodeTaskMutationRequest } from "../../task/mutation.js";
@@ -191,11 +193,11 @@ function lifecycleMutationRequest(command) {
             throw new Error(`task action cannot forward: ${command.action}`);
     }
 }
-async function mutationRequest(command, input, current) {
+async function mutationRequest(command, input, current, composeMarkdown) {
     if (command.action === "add")
         return await addMutationRequest(command, input, current);
     if (command.action === "compose")
-        return { action: "task.compose", markdown: await input.readStdin(), namespace: current };
+        return { action: "task.compose", markdown: composeMarkdown ?? (await input.readStdin()), namespace: current };
     if (command.action === "update")
         return await updateMutationRequest(command, input);
     return lifecycleMutationRequest(command);
@@ -296,22 +298,23 @@ function missingWorld(command) {
         return { kind: "absent" };
     if (command.action === "compose" && command.flags.plan === true)
         return { kind: "absent" };
-    if (command.action === "namespace")
-        return { kind: "accepted", value: [] };
+    if (command.action === "context")
+        return { kind: "accepted", value: { namespace: [], source: "default-root" } };
     if (command.action === "hold" || command.action === "done" || command.action === "drop") {
         return { items: command.positionals.map((id) => ({ id: id, outcome: missing(id) })) };
     }
     return missing(command.positionals[0]);
 }
-async function invokeLocalMutation(tasks, command, input, current) {
+async function invokeLocalMutation(input) {
+    const { tasks, command, edge, current, composeMarkdown, composeNamespace } = input;
     if (isWorldObservation(command))
         return observeWorldRead(tasks, command, current);
     if (command.action === "show" || command.action === "tree")
         return invokeRead(tasks, command, current);
     if (command.action === "add")
-        return await invokeAdd(tasks, command, input, current ?? []);
+        return await invokeAdd(tasks, command, edge, current ?? []);
     if (command.action === "update")
-        return await invokeUpdate(tasks, command, input.readStdin);
+        return await invokeUpdate(tasks, command, edge.readStdin);
     const id = command.positionals[0];
     switch (command.action) {
         case "start":
@@ -330,17 +333,22 @@ async function invokeLocalMutation(tasks, command, input, current) {
             const note = value(command, "note");
             return tasks.batch({ verb: "drop", ids: command.positionals, ...(note === undefined ? {} : { note }) });
         }
-        case "namespace": {
+        case "context": {
             const selected = namespace(command.positionals[0]);
-            if (selected !== undefined)
-                await writeTaskNamespaceContext(input.context.directory, selected);
-            return { kind: "accepted", value: selected ?? current ?? [] };
+            if (selected !== undefined) {
+                await writeTaskNamespaceContext(edge.context.writeRoot ?? edge.context.directory, selected);
+                const resolved = await resolveTaskNamespaceContext(edge.context);
+                if (typeof resolved === "object" && "kind" in resolved)
+                    return { kind: "refused", refusal: resolved };
+                return { kind: "accepted", value: resolved };
+            }
+            return { kind: "accepted", value: { namespace: current ?? [], source: "default-root" } };
         }
         case "compose":
             return tasks.compose({
-                markdown: await input.readStdin(),
-                namespace: current ?? [],
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
+                markdown: composeMarkdown ?? (await edge.readStdin()),
+                namespace: composeNamespace ?? current ?? [],
+                ...(edge.actor === undefined ? {} : { actor: edge.actor }),
                 ...(command.flags.plan === true ? { plan: true } : {}),
             });
         default:
@@ -350,24 +358,32 @@ async function invokeLocalMutation(tasks, command, input, current) {
 function establishesWorld(command) {
     return (command.action === "add" ||
         (command.action === "compose" && command.flags.plan !== true) ||
-        (command.action === "namespace" && command.positionals.length > 0));
+        (command.action === "context" && command.positionals.length > 0));
 }
 function forwardsMutation(command) {
     return (command.action !== "show" &&
         command.action !== "tree" &&
-        command.action !== "namespace" &&
+        command.action !== "context" &&
         !(command.action === "compose" && command.flags.plan === true) &&
         !isWorldObservation(command));
 }
+// eslint-disable-next-line complexity -- this is the single CLI edge ordering world, context, forwarding, and local execution.
 export async function invokeTask(command, input) {
     const planOnly = command.action === "compose" && command.flags.plan === true;
+    const composeMarkdown = command.action === "compose" ? await input.readStdin() : undefined;
+    const composition = composeMarkdown === undefined ? undefined : taskCompositionNamespaceHeader(composeMarkdown);
+    const explicitNamespace = command.action === "add"
+        ? namespace(value(command, "namespace"))
+        : command.action === "compose" && composition?.specified
+            ? composition.namespace
+            : undefined;
     const world = input.world ?? (planOnly ? input.candidate : establishesWorld(command) ? await input.establish() : null);
     if (world === null)
         return missingWorld(command);
     const tasks = Tasks.of(world);
-    const contextSensitive = command.action === "namespace" ||
-        command.action === "add" ||
-        command.action === "compose" ||
+    const contextSensitive = command.action === "context" ||
+        (command.action === "add" && explicitNamespace === undefined) ||
+        (command.action === "compose" && composition?.specified !== true) ||
         ((command.action === "ls" ||
             command.action === "ready" ||
             command.action === "blocked" ||
@@ -378,12 +394,22 @@ export async function invokeTask(command, input) {
         const resolved = await resolveTaskNamespaceContext(input.context);
         if (typeof resolved === "object" && "kind" in resolved)
             return { kind: "refused", refusal: resolved };
-        current = resolved;
+        current = resolved.namespace;
+        if (command.action === "context" && command.positionals.length === 0) {
+            return { kind: "accepted", value: resolved };
+        }
     }
     const requests = injectedBodyRequests();
     if (requests !== null && forwardsMutation(command)) {
-        const request = validatedMutationRequest(await mutationRequest(command, input, current ?? []));
+        const request = validatedMutationRequest(await mutationRequest(command, input, explicitNamespace ?? current ?? [], composeMarkdown));
         return (await requestBodyTask({ directory: requests, world, request }));
     }
-    return await invokeLocalMutation(tasks, command, input, current);
+    return await invokeLocalMutation({
+        tasks,
+        command,
+        edge: input,
+        ...(current === undefined ? {} : { current }),
+        ...(composeMarkdown === undefined ? {} : { composeMarkdown }),
+        ...(explicitNamespace === undefined ? {} : { composeNamespace: explicitNamespace }),
+    });
 }

package/build/src/cli/commands/task.d.ts

@@ -1,5 +1,5 @@
 import { type TaskQueryExpression } from "./task-query.js";
-export type TaskAction = "add" | "show" | "ls" | "ready" | "blocked" | "tree" | "doctor" | "update" | "query" | "start" | "stop" | "hold" | "resume" | "done" | "drop" | "namespace" | "compose";
+export type TaskAction = "add" | "show" | "ls" | "ready" | "blocked" | "tree" | "doctor" | "update" | "query" | "start" | "stop" | "hold" | "resume" | "done" | "drop" | "context" | "compose";
 type TaskFlagValue = string | true | readonly string[];
 type TaskStdin = "document" | "body" | "append" | "note" | "compose";
 export type ParsedTaskCommand = Readonly<{

package/build/src/cli/commands/task.js

@@ -38,18 +38,21 @@ task add [--namespace <ns>] [--actor <actor>] -`,
         flags: { ...COMMON, closed: "boolean", all: "boolean", world: "boolean", limit: "value" },
         usage: "task ls [--closed | --all] [--world] [--limit <n>]",
         purpose: "List Tasks in the selected scope.",
+        details: "--world lists every namespace in the current Task world.",
     },
     ready: {
         arity: [0, 0],
         flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" },
         usage: "task ready [--world] [--parent <TaskId>] [--limit <n>]",
         purpose: "List open Tasks whose every need is terminal.",
+        details: "--world lists every namespace in the current Task world.",
     },
     blocked: {
         arity: [0, 0],
         flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" },
         usage: "task blocked [--world] [--parent <TaskId>] [--limit <n>]",
         purpose: "List Tasks blocked by dependencies.",
+        details: "--world lists every namespace in the current Task world.",
     },
     query: {
         arity: [0, 0],
@@ -60,6 +63,7 @@ task add [--namespace <ns>] [--actor <actor>] -`,
         details: [
             "fields: state priority title id parent under needs blocks ready blocked created updated",
             "operators: = != < > <= >= ~ and or not ( )",
+            "--world lists every namespace in the current Task world.",
             "examples:",
             "  keiyaku task query --where 'priority <= 1 and ready' --world",
             "  keiyaku task query --where 'updated < 2026-08-06T00:00:00.000Z' --world",
@@ -124,11 +128,11 @@ task add [--namespace <ns>] [--actor <actor>] -`,
         usage: "task drop <TaskId>... [--note <text>]",
         purpose: "Drop one or more Tasks.",
     },
-    namespace: {
+    context: {
         arity: [0, 1],
         flags: COMMON,
-        usage: "task namespace [<namespace>]",
-        purpose: "Read or replace the current Task namespace.",
+        usage: "task context [<namespace>]",
+        purpose: "Read or replace the directory Task context.",
     },
     compose: {
         arity: [0, 0],

package/build/src/cli/coordinates.d.ts

@@ -10,6 +10,8 @@ export type CliCoordinates = Readonly<{
     taskContext: Readonly<{
         directory: string;
         boundary: string;
+        writeRoot: string;
+        managed: boolean;
     }>;
     establishWorld: () => Promise<WorldRoot>;
 }>;

package/build/src/cli/coordinates.js

@@ -1,4 +1,4 @@
-import { realpath } from "node:fs/promises";
+import { lstat, realpath } from "node:fs/promises";
 import { resolve } from "node:path";
 import { NoGitWorldError, Repo } from "../library/repo.js";
 import { World, WorldError } from "../world.js";
@@ -24,6 +24,17 @@ async function discoverRepoAt(coordinate, gitPath) {
         throw error;
     }
 }
+async function managedContractWorktree(root) {
+    try {
+        const stat = await lstat(resolve(root, ".keiyaku", "KEIYAKU.md"));
+        return stat.isFile() && !stat.isSymbolicLink();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
 function repoFor(use, discovery) {
     if (use === "none")
         return undefined;
@@ -72,7 +83,12 @@ export async function resolveCliCoordinates(input) {
         ...(repo === undefined ? {} : { repo }),
         world: world.root,
         candidateWorld: world.candidate,
-        taskContext: { directory: cwd, boundary },
+        taskContext: {
+            directory: cwd,
+            boundary,
+            writeRoot: worldRepo === undefined ? boundary : cwd,
+            managed: await managedContractWorktree(boundary),
+        },
         establishWorld: world.establish,
     };
 }

package/build/src/cli/render/task.js

@@ -319,11 +319,12 @@ function renderTaskValue(command, result, columns) {
     }
     if (command.action === "doctor")
         return renderDoctor(result);
-    if (command.action === "namespace") {
-        const namespace = result;
-        if (namespace.kind !== "accepted")
-            return renderFailure(command.action, namespace, columns);
-        return `namespace ${namespace.value.length === 0 ? "root" : namespace.value.join("/")}`;
+    if (command.action === "context") {
+        const context = result;
+        if (context.kind !== "accepted")
+            return renderFailure(command.action, context, columns);
+        const value = context.value.namespace.length === 0 ? "root" : context.value.namespace.join("/");
+        return `context ${value} · ${context.value.source}`;
     }
     if (command.action === "compose")
         return renderCompose(result, columns);

package/build/src/cli/square-edge.js

@@ -44,13 +44,13 @@ export async function recognizeAndListen(worldRoot, environment, allocated) {
             }
         }
         if (bound)
-            unbindCurrentParticipant(path, name, environment);
+            await unbindCurrentParticipant(path, name, environment);
     };
     try {
         const joinedResult = await square.joinWithActivity(name);
         joined = joinedResult.activity !== null;
         const participant = joinedResult.participant;
-        bound = bindCurrentParticipant(path, name, environment).created;
+        bound = (await bindCurrentParticipant(path, name, environment)).created;
         const listener = participant;
         const change = await listener.listen(allocated.id);
         listening = change.activity !== null;

package/build/src/git/repository.d.ts

@@ -42,6 +42,8 @@ export declare function commonGitDirectory(repository: GitRepository): string;
 export declare function worktreeGitDirectory(repository: GitRepository, worktree: string): Promise<string>;
 export declare function worktreeRoot(repository: GitRepository): Promise<string>;
 export declare function readRef(repository: GitRepository, ref: string): Promise<GitOid | null>;
+/** Read an explicit set of asserted refs from one fresh Git observation. */
+export declare function readRefs(repository: GitRepository, refs: readonly string[]): Promise<Map<any, any>>;
 export declare function readTreeEntries(repository: GitRepository, tree: GitOid): Promise<Map<string, TreeEntry>>;
 export declare function readGit(repository: GitRepository): Promise<GitSnapshot>;
 /** Read only the requested private Git paths from one immutable Git tree. */

package/build/src/git/repository.js

@@ -113,9 +113,6 @@ export async function worktreeGitDirectory(repository, worktree) {
 export async function worktreeRoot(repository) {
     return await absoluteGitPath(repository, ["--show-toplevel"], "worktree root");
 }
-function assertOid(oid, label) {
-    gitObjectId(oid, label);
-}
 function assertRef(ref) {
     if (!ref.startsWith("refs/") || /[\s\0]/.test(ref) || ref.endsWith("/") || ref.includes("..")) {
         throw new Error(`invalid Git ref: ${ref}`);
@@ -129,10 +126,7 @@ export async function readRef(repository, ref) {
     assertAssertionRef(ref);
     try {
         const oid = (await runGit(repository, ["rev-parse", "--verify", "--quiet", ref])).toString("utf8").trim();
-        if (oid.length === 0)
-            return null;
-        assertOid(oid, `ref ${ref}`);
-        return oid;
+        return oid.length === 0 ? null : gitObjectId(oid, `ref ${ref}`);
     }
     catch (error) {
         if (error instanceof GitPlumbingError && error.status === 1)
@@ -140,10 +134,29 @@ export async function readRef(repository, ref) {
         throw error;
     }
 }
+/** Read an explicit set of asserted refs from one fresh Git observation. */
+export async function readRefs(repository, refs) {
+    const refsToRead = [...new Set(refs)];
+    for (const ref of refsToRead)
+        assertAssertionRef(ref);
+    if (refsToRead.length === 0)
+        return new Map();
+    const output = (await runGit(repository, ["cat-file", "--batch-check=%(objectname)"], `${refsToRead.join("\n")}\n`)).toString("utf8");
+    const records = output.split("\n");
+    if (records.pop() !== "" || records.length !== refsToRead.length)
+        throw new Error("Git ref batch output is malformed");
+    return new Map(refsToRead.map((ref, index) => {
+        const oid = records[index];
+        if (oid === `${ref} missing`)
+            return [ref, null];
+        gitObjectId(oid, `ref ${ref}`);
+        return [ref, oid];
+    }));
+}
 async function readTreeForCommit(repository, commit) {
-    assertOid(commit, "Git commit");
+    gitObjectId(commit, "Git commit");
     const tree = (await runGit(repository, ["show", "-s", "--format=%T", commit])).toString("utf8").trim();
-    assertOid(tree, "Git tree");
+    gitObjectId(tree, "Git tree");
     return tree;
 }
 function parseTreeEntries(output) {
@@ -159,13 +172,13 @@ function parseTreeEntries(output) {
         if (mode === undefined || type === undefined || oid === undefined || path.length === 0) {
             throw new GitPlumbingError({ stderr: record, status: null, message: `malformed ls-tree record: ${record}` });
         }
-        assertOid(oid, `tree entry ${path}`);
+        gitObjectId(oid, `tree entry ${path}`);
         entries.set(path, { mode, type, oid });
     }
     return entries;
 }
 export async function readTreeEntries(repository, tree) {
-    assertOid(tree, "tree");
+    gitObjectId(tree, "tree");
     const output = await runGit(repository, ["ls-tree", "-r", "-z", "--full-tree", tree]);
     return parseTreeEntries(output);
 }
@@ -193,11 +206,11 @@ export async function readGitPaths(repository, requestedPaths) {
 }
 export async function writeBlob(repository, bytes) {
     const oid = (await runGit(repository, ["hash-object", "-w", "--stdin"], bytes)).toString("utf8").trim();
-    assertOid(oid, "written blob");
+    gitObjectId(oid, "written blob");
     return oid;
 }
 export async function readBlob(repository, oid) {
-    assertOid(oid, "blob");
+    gitObjectId(oid, "blob");
     return await runGit(repository, ["cat-file", "blob", oid]);
 }
 function malformedBatchOutput(detail) {
@@ -210,7 +223,7 @@ function malformedBatchOutput(detail) {
 async function readObjects(repository, oids) {
     const unique = [...new Set(oids)];
     for (const oid of unique)
-        assertOid(oid, "Git object");
+        gitObjectId(oid, "Git object");
     if (unique.length === 0)
         return new Map();
     const output = await runGit(repository, ["cat-file", "--batch"], `${unique.join("\n")}\n`);
@@ -305,7 +318,7 @@ async function writePreparedTrees(repository, prepared) {
     for (let index = 0; index < prepared.length; index += 1) {
         const expected = prepared[index].oid;
         const actual = written[index];
-        assertOid(actual, "written tree");
+        gitObjectId(actual, "written tree");
         if (actual !== expected) {
             throw new GitPlumbingError({ stderr: output, status: null, message: `mktree wrote unexpected tree: ${actual}` });
         }
@@ -338,9 +351,9 @@ export async function updateGitTreeFromFrozenDirectories(repository, baseTree, d
 }
 async function writeCommitObject(input) {
     const { repository, tree, parents, message, actor, email, at } = input;
-    assertOid(tree, "commit tree");
+    gitObjectId(tree, "commit tree");
     for (const parent of parents)
-        assertOid(parent, "commit parent");
+        gitObjectId(parent, "commit parent");
     const args = ["commit-tree", tree];
     for (const parent of parents)
         args.push("-p", parent);
@@ -353,7 +366,7 @@ async function writeCommitObject(input) {
     }))
         .toString("utf8")
         .trim();
-    assertOid(commit, "written Git commit");
+    gitObjectId(commit, "written Git commit");
     return commit;
 }
 export async function writeCommit(input) {
@@ -369,7 +382,7 @@ export async function writeCommit(input) {
 }
 function refAssertionLine(assertion) {
     assertAssertionRef(assertion.ref);
-    assertOid(assertion.oid, `expected oid for ${assertion.ref}`);
+    gitObjectId(assertion.oid, `expected oid for ${assertion.ref}`);
     return `${assertion.ref === "HEAD" ? "" : "option no-deref\n"}verify ${assertion.ref} ${assertion.oid}`;
 }
 function refUpdateLine(update, index) {
@@ -378,9 +391,9 @@ function refUpdateLine(update, index) {
         throw new Error(`duplicate ref update: ${update.ref}`);
     if (index > 0 && update.expectedOid === null)
         throw new Error("target ref updates require non-null OIDs");
-    assertOid(update.newOid, `new oid for ${update.ref}`);
+    gitObjectId(update.newOid, `new oid for ${update.ref}`);
     if (update.expectedOid !== null)
-        assertOid(update.expectedOid, `expected oid for ${update.ref}`);
+        gitObjectId(update.expectedOid, `expected oid for ${update.ref}`);
     return `option no-deref\nupdate ${update.ref} ${update.newOid} ${update.expectedOid ?? "0".repeat(update.newOid.length)}`;
 }
 export async function updateRefsAtomically(repository, updates, assertions = []) {

package/build/src/git/target-placement.js

@@ -280,8 +280,6 @@ async function classifyCheckout(input) {
     const candidateWorkspace = await workspaceMatchesTreeOnPaths(repository, path, candidateTree, workspaceTree, changedPaths);
     if (candidateIndex && candidateWorkspace)
         return { kind: "complete" };
-    if (workspaceTree === candidateTree)
-        return { kind: "recoverable", action: "candidate-index" };
     const predecessorIndex = await indexMatchesTreeOnPaths(repository, path, predecessorTree, changedPaths);
     if (predecessorIndex && candidateWorkspace)
         return { kind: "recoverable", action: "index-merge" };
@@ -305,10 +303,6 @@ async function recoverCheckout(input) {
     if (classified.kind === "retained")
         return "retained";
     const { repository, path, predecessor, candidate } = input;
-    if (classified.action === "candidate-index") {
-        await runGit(repository, ["-C", path, "read-tree", gitObjectIdForSnapshot(candidate)]);
-        return "recovered";
-    }
     if (classified.action === "index-merge") {
         await runGit(repository, [
             "-C",

package/build/src/protocol/attempt.js

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { encodeEntry } from "../core/facts/codec.js";
 import { admit } from "../git/admission.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { GIT_REF, readRef } from "../git/repository.js";
+import { GIT_REF, readRefs } from "../git/repository.js";
 import { foldJournal } from "../core/facts/fold.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { entryUlid, } from "../core/facts/types.js";
@@ -78,12 +78,17 @@ function recoveredAcceptance(observation, offer, primaryContract) {
     };
 }
 async function publicationPremiseMoved(repository, observation, offer, assertions) {
-    if ((await readRef(repository, GIT_REF)) !== observation.admission.snapshot.commit)
+    const refs = await readRefs(repository, [
+        GIT_REF,
+        ...assertions.map((assertion) => assertion.ref),
+        ...(offer.target === undefined ? [] : [offer.target.target]),
+    ]);
+    if (refs.get(GIT_REF) !== observation.admission.snapshot.commit)
         return true;
     for (const assertion of assertions)
-        if ((await readRef(repository, assertion.ref)) !== assertion.oid)
+        if (refs.get(assertion.ref) !== assertion.oid)
             return true;
-    return offer.target !== undefined && (await readRef(repository, offer.target.target)) !== offer.target.expectedOid;
+    return offer.target !== undefined && refs.get(offer.target.target) !== offer.target.expectedOid;
 }
 /** Admit one decided offer without making another legal decision. */
 export async function admitDecidedOffer(input) {

package/build/src/task/compose-language.d.ts

@@ -2,6 +2,10 @@ import type { TaskBoard } from "./board.js";
 import { type TaskDocument } from "./document.js";
 import { type TaskId } from "./identity.js";
 import { type TaskCompositionDiagnostic } from "./operations.js";
+export declare function taskCompositionNamespaceHeader(markdown: string): Readonly<{
+    specified: boolean;
+    namespace?: readonly string[];
+}>;
 export type TaskCompositionAlias = Readonly<{
     alias: string;
     taskId: TaskId;

package/build/src/task/compose-language.js

@@ -2,6 +2,13 @@ import { serializeTaskDocument } from "./document.js";
 import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
 import { parseTaskComposition } from "./compose-parser.js";
 import { advanceTaskTimestamp } from "./operations.js";
+export function taskCompositionNamespaceHeader(markdown) {
+    const parsed = parseTaskComposition(markdown);
+    return {
+        specified: parsed.namespaceSpecified,
+        ...(parsed.namespace === undefined ? {} : { namespace: parsed.namespace }),
+    };
+}
 function diagnostic(line, reason, token) {
     return { line, reason, token };
 }

package/build/src/task/compose-parser.d.ts

@@ -25,6 +25,7 @@ export type ParsedNode = Readonly<{
 }>;
 export type ParsedComposition = Readonly<{
     namespace?: readonly string[];
+    namespaceSpecified: boolean;
     nodes: readonly ParsedNode[];
     diagnostics: readonly TaskCompositionDiagnostic[];
 }>;

package/build/src/task/compose-parser.js

@@ -32,8 +32,10 @@ function withoutFenceSeparator(value) {
     return value;
 }
 function parseNamespace(value) {
-    if (value === "")
+    if (value === "/")
         return [];
+    if (value === "")
+        throw new Error("empty compose namespace; use ns=/ for root");
     return parseTaskId(`task/${value}/placeholder`).namespace;
 }
 function parseAssignment(text, line) {
@@ -174,5 +176,5 @@ export function parseTaskComposition(source) {
             replaceNode(nodes, current);
         }
     }
-    return { ...(namespace === undefined ? {} : { namespace }), nodes, diagnostics };
+    return { ...(namespace === undefined ? {} : { namespace }), namespaceSpecified: sawNamespace, nodes, diagnostics };
 }

package/build/src/task/compose.d.ts

@@ -3,6 +3,7 @@ import { type TaskCompositionAlias, type TaskCompositionBodyPreview } from "./co
 import type { TaskId } from "./identity.js";
 import type { TaskRefusal, TaskRetry } from "./operations.js";
 export type { TaskCompositionAlias, TaskCompositionBodyPreview } from "./compose-language.js";
+export { taskCompositionNamespaceHeader } from "./compose-language.js";
 export type TaskDocumentChange = Readonly<{
     taskId: TaskId;
     kind: "created" | "updated";

package/build/src/task/compose.js

@@ -2,6 +2,7 @@ import { documentDiff } from "../markdown/diff.js";
 import { planTaskComposition, } from "./compose-language.js";
 import { serializeTaskDocument } from "./document.js";
 import { authorityPath, readBoard, replaceAuthority, withTaskLocks } from "./store.js";
+export { taskCompositionNamespaceHeader } from "./compose-language.js";
 function refusal(diagnostics) {
     return { kind: "refused", refusal: { kind: "invalid-composition", diagnostics } };
 }
@@ -46,7 +47,7 @@ function recoveryDraft(namespace, remaining) {
         if (task.kind === "new" && task.alias !== undefined)
             aliases.set(task.after.id, task.alias);
     }
-    const lines = [`ns=${namespace.join("/")}`];
+    const lines = [`ns=${namespace.length === 0 ? "/" : namespace.join("/")}`];
     for (const task of remaining)
         lines.push("", ...taskDraft(task, aliases));
     return `${lines.join("\n")}\n`;

package/build/src/task/context.d.ts

@@ -5,11 +5,17 @@ export type NamespaceContextRead = readonly string[] | "absent" | Readonly<{
 export type NamespaceContextInput = Readonly<{
     directory: string;
     boundary: string;
+    managed?: boolean;
+}>;
+export type NamespaceContextSource = "default-root" | "contract-installed" | "local-override";
+export type ResolvedNamespaceContext = Readonly<{
+    namespace: readonly string[];
+    source: NamespaceContextSource;
 }>;
 export declare function readNamespaceContext(coordinates: NamespaceContextInput): Promise<NamespaceContextRead>;
 export declare function installNamespaceContext(root: string, segments: readonly string[]): Promise<void>;
 export declare function repairNamespaceContext(root: string, segments: readonly string[]): Promise<"kept" | "installed">;
-export declare function resolveTaskNamespaceContext(input: NamespaceContextInput): Promise<readonly string[] | Readonly<{
+export declare function resolveTaskNamespaceContext(input: NamespaceContextInput): Promise<ResolvedNamespaceContext | Readonly<{
     kind: "invalid-namespace-context";
     path: string;
 }>>;

package/build/src/task/context.js

@@ -40,6 +40,12 @@ async function readAt(root) {
     const segments = content === "" ? [] : content.split("/");
     return validNamespaceSegments(segments) ? segments : { kind: "malformed", path: currentPath(root) };
 }
+async function readAtWithPath(root) {
+    const selected = await readAt(root);
+    if (selected === "absent" || (typeof selected === "object" && "kind" in selected))
+        return selected;
+    return { value: selected, path: currentPath(root) };
+}
 export async function readNamespaceContext(coordinates) {
     let current = coordinates.directory;
     for (;;) {
@@ -75,12 +81,25 @@ export async function repairNamespaceContext(root, segments) {
     return "installed";
 }
 export async function resolveTaskNamespaceContext(input) {
-    const selected = await readNamespaceContext(input);
-    return selected === "absent"
-        ? []
-        : typeof selected === "object" && "kind" in selected
-            ? { kind: "invalid-namespace-context", path: selected.path }
-            : selected;
+    let current = input.directory;
+    for (;;) {
+        const selected = await readAtWithPath(current);
+        if (selected !== "absent") {
+            if (typeof selected === "object" && "kind" in selected)
+                return { kind: "invalid-namespace-context", path: selected.path };
+            return {
+                namespace: "value" in selected ? selected.value : selected,
+                source: current === input.boundary && input.managed === true ? "contract-installed" : "local-override",
+            };
+        }
+        if (current === input.boundary)
+            return { namespace: [], source: "default-root" };
+        const resolvedParent = dirname(resolve(current));
+        if (resolvedParent === current || !resolvedParent.startsWith(`${input.boundary}/`)) {
+            return { namespace: [], source: "default-root" };
+        }
+        current = resolvedParent;
+    }
 }
 export async function writeTaskNamespaceContext(directory, value) {
     await installNamespaceContext(directory, value);