@astrosheep/keiyaku 4.0.6 → 4.1.0

package/build/src/library/contract.js

@@ -25,6 +25,7 @@ import { reconcileInput, scopeForRepo } from "./repo.js";
 import { injectedBodyRequests, requestBodyDeliver, requestBodyReview, } from "../akuma/requests.js";
 import { auditContract } from "./audit.js";
 import { Delivery, deliveryHandle } from "./delivery.js";
+import { continueDeliveredDependents } from "./continuation.js";
 import { completionInput, completeHolderMutation, completeMutation, } from "./mutation.js";
 import { completeReconcile } from "./reconcile.js";
 import { admitBindWithAppointment } from "./bind.js";
@@ -75,9 +76,22 @@ async function executeLocalDelivery(input) {
         });
         if (outcome.kind === "integration-conflict-materialized")
             return outcome;
+        const accepted = requireAccepted(outcome);
+        const continued = accepted.value.completion === undefined
+            ? accepted
+            : await continueDeliveredDependents({
+                scope: input.scope,
+                channel,
+                contractId: input.contractId,
+                accepted,
+                deriveDocument: derivedDocument,
+                resolveHereWorkspace: async (id) => await resolveHereWorkspace(input.scope, id),
+                ...(input.actor === undefined ? {} : { actor: input.actor }),
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+            });
         return completeMutation({
             ...completionInput(input.scope, channel, input.contractId, (delivery) => delivery, input.hooks),
-            accepted: requireAccepted(outcome),
+            accepted: continued,
         });
     });
 }
@@ -93,9 +107,20 @@ async function executeLocalReview(input) {
             ...(input.actor === undefined ? {} : { actor: input.actor }),
             resolveHereWorkspace: async (id) => await resolveHereWorkspace(input.scope, id),
         }));
+        const continued = accepted.value.completion === undefined
+            ? accepted
+            : await continueDeliveredDependents({
+                scope: input.scope,
+                channel,
+                contractId: input.contractId,
+                accepted,
+                deriveDocument: derivedDocument,
+                resolveHereWorkspace: async (id) => await resolveHereWorkspace(input.scope, id),
+                ...(input.actor === undefined ? {} : { actor: input.actor }),
+            });
         return completeMutation({
             ...completionInput(input.scope, channel, input.contractId, (review) => review, input.hooks),
-            accepted,
+            accepted: continued,
         });
     });
 }

package/build/src/library/delivery.d.ts

@@ -1,19 +1,24 @@
 import type { SnapshotId } from "../core/facts/types.js";
-import type { DeliverValue } from "../protocol/deliver.js";
+import type { DeliverValue as ProtocolDeliverValue } from "../protocol/deliver.js";
+import type { ContinuationReport } from "./continuation.js";
+export type DeliveryValue = ProtocolDeliverValue & Readonly<{
+    continuation?: ContinuationReport;
+}>;
 declare class DeliveryHandle {
     private readonly readDiff;
-    readonly completion?: DeliverValue["completion"];
-    readonly verification?: DeliverValue["verification"];
-    readonly verificationReuse?: DeliverValue["verificationReuse"];
-    readonly verificationSummary?: DeliverValue["verificationSummary"];
-    readonly placement?: DeliverValue["placement"];
-    readonly cleanup?: DeliverValue["cleanup"];
-    readonly leak?: DeliverValue["leak"];
+    readonly completion?: DeliveryValue["completion"];
+    readonly verification?: DeliveryValue["verification"];
+    readonly verificationReuse?: DeliveryValue["verificationReuse"];
+    readonly verificationSummary?: DeliveryValue["verificationSummary"];
+    readonly placement?: DeliveryValue["placement"];
+    readonly cleanup?: DeliveryValue["cleanup"];
+    readonly leak?: DeliveryValue["leak"];
+    readonly continuation?: DeliveryValue["continuation"];
     readonly tenderSnapshot: SnapshotId;
-    readonly integration: DeliverValue["integration"];
-    readonly method: DeliverValue["method"];
-    readonly policy: DeliverValue["policy"];
-    constructor(identity: Pick<DeliverValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliverValue, "completion" | "verification" | "verificationReuse" | "verificationSummary" | "placement" | "cleanup" | "leak">>);
+    readonly integration: DeliveryValue["integration"];
+    readonly method: DeliveryValue["method"];
+    readonly policy: DeliveryValue["policy"];
+    constructor(identity: Pick<DeliveryValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliveryValue, "completion" | "verification" | "verificationReuse" | "verificationSummary" | "placement" | "cleanup" | "leak" | "continuation">>);
     diff(): Promise<string | null>;
 }
 export type Delivery = DeliveryHandle;
@@ -22,5 +27,5 @@ type HandleType<T extends object> = Readonly<{
     [Symbol.hasInstance](value: unknown): boolean;
 }>;
 export declare const Delivery: HandleType<DeliveryHandle>;
-export declare function deliveryHandle(delivery: DeliverValue, readDiff: () => Promise<string | null>): Delivery;
+export declare function deliveryHandle(delivery: DeliveryValue, readDiff: () => Promise<string | null>): Delivery;
 export {};

package/build/src/library/keiyaku.d.ts

@@ -8,7 +8,7 @@ export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";
-export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, IntegrationConflictMaterialized, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
+export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, ContinuationReport, DeliverInput, Fact, IntegrationConflictMaterialized, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
 export type { ContractId, ContractState, ChangeId, SnapshotId, } from "../core/facts/types.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
 export type { RegionOverlap } from "./region.js";

package/build/src/library/mutation.js

@@ -5,7 +5,11 @@ export function completionInput(scope, channel, contractId, value, hooks) {
 }
 export async function completeMutation(input) {
     const { scope, channel, contractId, accepted, value, hooks } = input;
-    const report = await completeReconcile({ scope, channel, contractId, hooks, retryHooks: false });
+    const contracts = [...new Set([contractId, ...accepted.facts.map((fact) => fact.contract)])];
+    const reports = [];
+    for (const affected of contracts) {
+        reports.push(await completeReconcile({ scope, channel, contractId: affected, hooks, retryHooks: false }));
+    }
     const obligations = {
         ...(accepted.cleanup === undefined ? {} : { cleanup: accepted.cleanup }),
         ...(accepted.leak === undefined ? {} : { leak: accepted.leak }),
@@ -14,9 +18,12 @@ export async function completeMutation(input) {
         facts: accepted.facts,
         head: accepted.head,
         value: value(accepted.value),
-        effects: [...(accepted.physical?.effects ?? []), ...report.effects],
-        lags: [...(accepted.physical?.lag ?? []), ...report.lag],
-        settlement: report.settlement,
+        effects: [...(accepted.physical?.effects ?? []), ...reports.flatMap((report) => report.effects)],
+        lags: [...(accepted.physical?.lag ?? []), ...reports.flatMap((report) => report.lag)],
+        settlement: {
+            actions: reports.flatMap((report) => report.settlement.actions),
+            lags: reports.flatMap((report) => report.settlement.lags),
+        },
         ...obligations,
     };
 }

package/build/src/protocol/deliver.d.ts

@@ -1,6 +1,6 @@
-import type { ActorId, ContractId, ContractState, DeliverData, SnapshotId } from "../core/facts/types.js";
+import type { ActorId, ContractId, ContractState, DeliverData, JournalEntry, SnapshotId } from "../core/facts/types.js";
 import type { CurrentVerifiedAttestation } from "./intent.js";
-import { type CompletionEvidence } from "./completion.js";
+import { type CompletionEvidence, type CompletionResult } from "./completion.js";
 import { type ManagedWorktreeAppointment } from "../workspace-place.js";
 import type { DeliveryPreparationRefusal, DocumentDerivation, IntentOutcome, MutationOperationInput } from "./operations.js";
 type DeliveryIdentity = DeliverData;
@@ -45,5 +45,15 @@ export declare function prepareDelivery(repository: import("../git/process.js").
     kind: "refused";
     refusal: DeliveryPreparationRefusal;
 }>;
+export declare function continueDeliveryOperation(input: Readonly<{
+    scope: MutationOperationInput["scope"];
+    channel: MutationOperationInput["channel"];
+    state: ContractState;
+    journal: readonly JournalEntry[];
+    deriveDocument: (state: ContractState) => DocumentDerivation;
+    resolveHereWorkspace?: MutationOperationInput["resolveHereWorkspace"];
+    actor?: ActorId;
+    signal?: AbortSignal;
+}>): Promise<CompletionResult>;
 export declare function deliverOperation(input: DeliverOperationInput): Promise<IntentOutcome<DeliverValue> | IntegrationConflictMaterialized>;
 export {};

package/build/src/protocol/deliver.js

@@ -34,10 +34,12 @@ export async function prepareDelivery(repository, stage, input) {
         coordinates,
         ...(appointed === undefined ? {} : { place: appointed.place }),
         ...(stage.workspacePath === undefined ? {} : { workspacePath: stage.workspacePath }),
+        captureMergeState: true,
+        rejectUnmerged: true,
     });
     if (tender.kind === "refused")
         return tender;
-    if ((tender.data.dirty && input.includeDirty !== true) || tender.data.changes.submodules.length > 0) {
+    if (((tender.data.dirty || tender.data.mergeHead !== undefined) && input.includeDirty !== true) || tender.data.changes.submodules.length > 0) {
         return { kind: "refused", refusal: await dirtyTenderRefusal(repository, contractId, tender.data) };
     }
     const commit = await prepareDeliveryCommitMetadata(repository, {
@@ -86,18 +88,23 @@ async function deliverAttempt(input, attempt) {
         workspacePath = state.terminal === null && state.coordinates.workspace === "here"
             ? await input.resolveHereWorkspace?.(state.id)
             : undefined;
-        const prepared = await prepareDelivery(input.scope, {
-            contractId: state.id,
-            coordinates: state.coordinates,
-            ...(workspacePath === undefined ? {} : { workspacePath }),
-        }, {
-            title: derivation.title,
-            document: derivation.bytes,
-            ...(input.actor === undefined ? {} : { actor: input.actor }),
-            ...(input.message === undefined ? {} : { message: input.message }),
-            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
-            includeDirty: input.includeDirty,
-        });
+        const materialization = input.materializeConflict === true && state.terminal === null
+            ? await materializationMergeStateRefusal(input)
+            : undefined;
+        const prepared = materialization === undefined
+            ? await prepareDelivery(input.scope, {
+                contractId: state.id,
+                coordinates: state.coordinates,
+                ...(workspacePath === undefined ? {} : { workspacePath }),
+            }, {
+                title: derivation.title,
+                document: derivation.bytes,
+                ...(input.actor === undefined ? {} : { actor: input.actor }),
+                ...(input.message === undefined ? {} : { message: input.message }),
+                requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
+                includeDirty: input.includeDirty,
+            })
+            : { kind: "refused", refusal: materialization };
         preparation = prepared.kind === "refused"
             ? { kind: "refused", document: derivation.document, refusal: prepared.refusal }
             : {
@@ -165,6 +172,24 @@ async function completeDelivery(input, first) {
         ...completed.evidence,
     });
 }
+export async function continueDeliveryOperation(input) {
+    const contractId = input.state.id;
+    const hereWorkspacePath = input.state.coordinates.workspace === "here"
+        ? await input.resolveHereWorkspace?.(contractId)
+        : undefined;
+    return await completeCandidate({
+        channel: input.channel,
+        repository: input.scope,
+        contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        ...(input.state.coordinates.target === undefined ? {} : { target: input.state.coordinates.target }),
+        verification: input.deriveDocument(input.state).verification,
+        initial: { kind: "accepted", state: input.state, journal: input.journal, facts: [] },
+        verifyInitial: true,
+        ...(hereWorkspacePath === undefined ? {} : { hereWorkspacePath }),
+    });
+}
 function isIntegrationConflict(refusal) {
     return refusal.kind === "integration-failed" && refusal.reason === "conflict";
 }
@@ -201,6 +226,17 @@ async function appointedDeliverWorkspace(input) {
         coordinates: state.coordinates,
     };
 }
+async function materializationMergeStateRefusal(input) {
+    const appointed = await appointedDeliverWorkspace(input);
+    if ("kind" in appointed)
+        return appointed.refusal;
+    return await mergeStatePresentRefusal(input, appointed.workspace);
+}
+async function mergeStatePresentRefusal(input, workspace) {
+    if (!(await workspaceMergeStatePresent(input.scope, workspace.path)))
+        return undefined;
+    return { kind: "merge-state-present", contractId: input.contractId, workspace };
+}
 async function materializeDeliverConflict(input, refusal) {
     if (refusal.conflictPaths === undefined)
         throw new Error("conflicted integration is missing conflict paths");
@@ -208,12 +244,9 @@ async function materializeDeliverConflict(input, refusal) {
     if ("kind" in appointed)
         return appointed;
     const { workspace, coordinates } = appointed;
-    if (await workspaceMergeStatePresent(input.scope, workspace.path)) {
-        return {
-            kind: "refused",
-            refusal: { kind: "merge-state-present", contractId: input.contractId, workspace },
-        };
-    }
+    const mergeState = await mergeStatePresentRefusal(input, workspace);
+    if (mergeState !== undefined)
+        return { kind: "refused", refusal: mergeState };
     const tender = await captureTender(input.scope, {
         contractId: input.contractId,
         coordinates,

package/build/src/protocol/operations.d.ts

@@ -1,4 +1,4 @@
-import { type DirtyWorkspaceRefusal } from "../git/tender.js";
+import type { DirtyWorkspaceRefusal } from "../git/tender.js";
 import type { GitRepository } from "../git/process.js";
 import { type GitDecodeChannel } from "../git/read-observation.js";
 import type { WorktreeLeak } from "../git/scratch.js";
@@ -28,6 +28,11 @@ export type MergeStatePresentRefusal = Readonly<{
         path: string;
     }>;
 }>;
+export type UnmergedPathsRefusal = Readonly<{
+    kind: "unmerged-paths";
+    contractId: ContractId;
+    paths: readonly string[];
+}>;
 export type DeliverConflictRefusal = Readonly<{
     kind: "integration-failed";
     contractId: ContractId;
@@ -42,7 +47,7 @@ export type DeliverConflictRefusal = Readonly<{
 export type DeliveryPreparationRefusal = Readonly<{
     kind: "target-missing" | "worktree-missing";
     contractId: ContractId;
-}> | DirtyWorkspaceRefusal | IntegrationPreparationRefusal | MergeStatePresentRefusal | TargetPlacementRefusal;
+}> | DirtyWorkspaceRefusal | UnmergedPathsRefusal | IntegrationPreparationRefusal | MergeStatePresentRefusal | TargetPlacementRefusal;
 export type IntentRefusal = AbandonRefusal | AmendRefusal | ArcRefusal | BindRefusal | DeliverRefusal | DeliveryPreparationRefusal | DeliverConflictRefusal | PlacementRefusal | AttestationRefusal | TargetInputRefusal | VerificationDeclarationRefusal;
 export type IntentRetry = ProtocolTerminal;
 export type IntentOutcome<Value, Refusal = IntentRefusal> = ProtocolIntentOutcome<Value, Refusal>;

package/build/src/settlement/fence.d.ts

@@ -3,5 +3,3 @@ import type { GitRepository } from "../git/process.js";
 import type { TaskId } from "../task/identity.js";
 export declare function settlementFencePath(repository: GitRepository, taskId: TaskId): string;
 export declare function acquireTaskSettlementFence(repository: GitRepository, taskId: TaskId): Promise<HeldSqliteTransactionLock>;
-/** Remove only the hash-addressed settlement fences owned by Contract/Git reset. */
-export declare function nukeSettlementFences(repository: GitRepository): Promise<void>;

package/build/src/settlement/fence.js

@@ -1,5 +1,4 @@
 import { createHash } from "node:crypto";
-import { readdir } from "node:fs/promises";
 import { resolve } from "node:path";
 import { acquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
 import { commonGitDirectory } from "../git/repository.js";
@@ -13,26 +12,3 @@ export function acquireTaskSettlementFence(repository, taskId) {
         mode: "immediate",
     });
 }
-/** Remove only the hash-addressed settlement fences owned by Contract/Git reset. */
-export async function nukeSettlementFences(repository) {
-    const root = resolve(commonGitDirectory(repository), "keiyaku", "locks", "settlement");
-    let entries;
-    try {
-        entries = await readdir(root, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return;
-        throw error;
-    }
-    for (const entry of entries) {
-        if (!/^[0-9a-f]{64}\.sqlite$/u.test(entry.name) || !entry.isFile() || entry.isSymbolicLink()) {
-            throw new Error(`Settlement fence custody is invalid: ${resolve(root, entry.name)}`);
-        }
-    }
-    for (const entry of entries) {
-        const path = resolve(root, entry.name);
-        const held = await acquireSqliteTransactionLock({ path, mode: "immediate" });
-        held.close();
-    }
-}

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

@@ -12,6 +12,12 @@ export type TaskRow = Readonly<{
     state: TaskState;
     priority: TaskPriority;
     disposition: TaskDisposition;
+    updatedAt: string;
+    bodyPresent: boolean;
+    children?: Readonly<{
+        live: number;
+        total: number;
+    }>;
 }>;
 export type BlockedTaskRow = TaskRow & Readonly<{
     blockers: readonly TaskRef[];
@@ -65,14 +71,21 @@ export declare function createTaskRelations(board: TaskBoard): TaskRelationProje
 export declare function taskDisposition(board: TaskBoard, task: TaskDocument): TaskDisposition;
 export declare function taskBlocked(board: TaskBoard, task: TaskDocument): boolean;
 export declare function projectDetailFacts(board: TaskBoard, id: TaskId, relations: TaskRelationProjection): TaskDetailFacts | null;
-export declare function projectRows(board: TaskBoard, scope: readonly string[] | null, selection: "active" | "closed" | "all"): readonly TaskRow[];
+export declare function projectTaskRow(board: TaskBoard, relations: TaskRelationProjection, task: TaskDocument): TaskRow;
+export declare function projectRows(board: TaskBoard, relations: TaskRelationProjection, scope: readonly string[] | null, selection: "active" | "closed" | "all"): readonly TaskRow[];
 export declare function projectBlocked(board: TaskBoard, scope: readonly string[] | null, relations: TaskRelationProjection): readonly BlockedTaskRow[];
-export declare function projectStatusRows(board: TaskBoard, scope: readonly string[] | null): (Readonly<{
+export declare function projectStatusRows(board: TaskBoard, relations: TaskRelationProjection, scope: readonly string[] | null): (Readonly<{
     id: TaskId;
     title: string;
     state: TaskState;
     priority: TaskPriority;
     disposition: TaskDisposition;
+    updatedAt: string;
+    bodyPresent: boolean;
+    children?: Readonly<{
+        live: number;
+        total: number;
+    }>;
 }> | {
     blockers: readonly Readonly<{
         id: TaskId;
@@ -84,6 +97,12 @@ export declare function projectStatusRows(board: TaskBoard, scope: readonly stri
     state: TaskState;
     priority: TaskPriority;
     disposition: TaskDisposition;
+    updatedAt: string;
+    bodyPresent: boolean;
+    children?: Readonly<{
+        live: number;
+        total: number;
+    }>;
 })[];
 export type TaskBoardObservation = Readonly<{
     statusRows: ReturnType<typeof projectStatusRows>;

package/build/src/task/board.js

@@ -79,33 +79,46 @@ export function projectDetailFacts(board, id, relations) {
     };
 }
 function inScope(task, scope) { return scope === null || sameNamespace(parseTaskId(task.id).namespace, scope); }
-export function projectRows(board, scope, selection) {
-    return [...board.tasks.values()].filter((task) => inScope(task, scope)).filter((task) => selection === "all"
-        || (selection === "closed") === terminal(task.state)).map((task) => ({
-        id: task.id, title: task.title, state: task.state, priority: task.priority,
+export function projectTaskRow(board, relations, task) {
+    const children = relations.children(task.id);
+    const total = children.length;
+    const live = children.filter((child) => child.state !== "done" && child.state !== "drop").length;
+    return {
+        id: task.id,
+        title: task.title,
+        state: task.state,
+        priority: task.priority,
         disposition: taskDisposition(board, task),
-    })).sort((a, b) => a.priority - b.priority || Buffer.compare(Buffer.from(a.id), Buffer.from(b.id)));
+        updatedAt: task.updatedAt,
+        bodyPresent: task.body.length > 0,
+        ...(total === 0 ? {} : { children: { live, total } }),
+    };
+}
+export function projectRows(board, relations, scope, selection) {
+    return [...board.tasks.values()].filter((task) => inScope(task, scope)).filter((task) => selection === "all"
+        || (selection === "closed") === terminal(task.state)).map((task) => projectTaskRow(board, relations, task))
+        .sort((a, b) => a.priority - b.priority || Buffer.compare(Buffer.from(a.id), Buffer.from(b.id)));
 }
 export function projectBlocked(board, scope, relations) {
-    return projectRows(board, scope, "active").flatMap((row) => {
+    return projectRows(board, relations, scope, "active").flatMap((row) => {
         if (!taskBlocked(board, board.tasks.get(row.id)))
             return [];
         return [{ ...row, blockers: projectDetailFacts(board, row.id, relations).blockers }];
     });
 }
-export function projectStatusRows(board, scope) {
-    const relations = createTaskRelations(board);
+export function projectStatusRows(board, relations, scope) {
     const blockers = new Map(projectBlocked(board, scope, relations).map((row) => [row.id, row.blockers]));
-    return projectRows(board, scope, "all").map((row) => {
+    return projectRows(board, relations, scope, "all").map((row) => {
         const unresolved = blockers.get(row.id);
         return unresolved === undefined ? row : { ...row, blockers: unresolved };
     });
 }
 export function projectTaskBoardObservation(board) {
-    const rows = projectRows(board, null, "all");
+    const relations = createTaskRelations(board);
+    const rows = projectRows(board, relations, null, "all");
     return {
-        statusRows: projectStatusRows(board, null),
-        selectNamespace: (namespace) => projectRows(board, namespace, "all"),
+        statusRows: projectStatusRows(board, relations, null),
+        selectNamespace: (namespace) => projectRows(board, relations, namespace, "all"),
         selectCreatedBy: (createdBy) => rows.filter((row) => board.tasks.get(row.id)?.createdBy === createdBy),
     };
 }

package/build/src/task/identity.js

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { identityCoordinate, identitySegments } from "../identity/coordinates.js";
-import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
-const STEM_BYTES = 48;
+import { normalizeIdentityStem } from "../identity/normalize.js";
+const STEM_CODE_POINTS = 32;
 export function isTaskSegment(value) {
     return value.length > 0 && value !== "." && value !== ".." && !value.includes("/")
         && normalizeIdentityStem({ source: value }) === value;
@@ -30,13 +30,23 @@ export function deriveLocalStem(title) {
     const stem = normalizeIdentityStem({ source: title });
     if (stem.length === 0)
         throw new TypeError("task title must contain a normalized identity segment");
-    return fitIdentityStem({ stem, maxBytes: STEM_BYTES });
+    const words = stem.split("-");
+    let fitted = words[0];
+    let count = [...fitted].length;
+    for (const word of words.slice(1)) {
+        const candidate = count + 1 + [...word].length;
+        if (candidate > STEM_CODE_POINTS)
+            break;
+        fitted += `-${word}`;
+        count = candidate;
+    }
+    return fitted;
 }
 export function allocateLocalId(stem, occupied) {
     if (!occupied.has(stem))
         return stem;
     for (let suffix = 2; Number.isSafeInteger(suffix); suffix += 1) {
-        const candidate = fitIdentityStem({ stem, maxBytes: STEM_BYTES, suffix: String(suffix) });
+        const candidate = `${stem}-${suffix}`;
         if (!occupied.has(candidate))
             return candidate;
     }

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

@@ -19,6 +19,7 @@ export type TaskDoctorReport = Readonly<{
 export type TaskDecompositionTree = TaskOutcome<TaskTreeNode>;
 export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResult, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort, TaskRelationPredicateField, };
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
+export declare function observeTaskDetails(world: WorldRoot, ids: readonly TaskId[]): Promise<TaskOutcome<readonly TaskDetail[]>>;
 declare class TaskHandle {
     readonly id: TaskId;
     private readonly world;

package/build/src/task/index.js

@@ -1,11 +1,17 @@
 import { buildTree, createTaskRelations, diagnoseBoard, projectDetailFacts, } from "./board.js";
 import { composeTasks } from "./compose.js";
 import { TaskAuthorityCorruptionError } from "./document.js";
-import { addTask, addTaskDocument, batchTasks, blockedTasks, lifecycleTask, listTasks, queryTasks, readyTasks, taskView, updateTask, } from "./operations.js";
+import { addTask, addTaskDocument, batchTasks, blockedTasks, lifecycleTask, listTasks, queryTasks, readTaskDetails, readyTasks, taskView, updateTask, } from "./operations.js";
 import { readBoard } from "./store.js";
 import { actor, addInput, closed, limit, namespace, record, signal, sort, taskId as id, taskIds, text, updateInput, } from "./input.js";
 import { normalizeTaskQuery, TASK_RELATION_PREDICATE_FIELDS, DEFAULT_TASK_LIMIT, } from "./query.js";
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
+export async function observeTaskDetails(world, ids) {
+    const observed = await readTaskDetails(world, ids);
+    if (observed.kind !== "accepted")
+        return observed;
+    return { kind: "accepted", value: observed.value.map((facts) => ({ ...facts, task: taskView(facts.task) })) };
+}
 class TaskHandle {
     id;
     world;

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

@@ -1,4 +1,4 @@
-import { type BlockedTaskRow, type TaskBoardObservation, type TaskRow } from "./board.js";
+import { type BlockedTaskRow, type TaskBoardObservation, type TaskDetailFacts, type TaskRow } from "./board.js";
 import { type TaskDocument, type TaskPriority, type TaskState } from "./document.js";
 import { type TaskId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
@@ -115,6 +115,7 @@ export declare function lifecycleTask(world: WorldRoot, id: TaskId, verb: TaskLi
 export declare function batchTasks(world: WorldRoot, verb: "done" | "drop" | "hold", ids: readonly TaskId[], signal?: AbortSignal, note?: string): Promise<TaskBatchResult>;
 export declare function settleTask(world: WorldRoot, id: TaskId): Promise<SettledTaskResult>;
 export declare function listTasks(world: WorldRoot, namespace: readonly string[] | undefined, selection: "active" | "closed" | "all", scope?: "namespace" | "world", limit?: number): Promise<TaskOutcome<TaskPage<TaskRow>>>;
+export declare function readTaskDetails(world: WorldRoot, ids: readonly TaskId[]): Promise<TaskOutcome<readonly TaskDetailFacts[]>>;
 export declare function readyTasks(world: WorldRoot, namespace: readonly string[] | undefined, scope?: "namespace" | "world", parent?: TaskId, limit?: number): Promise<TaskOutcome<TaskPage<TaskRow>>>;
 export declare function blockedTasks(world: WorldRoot, namespace: readonly string[] | undefined, scope?: "namespace" | "world", parent?: TaskId, limit?: number): Promise<TaskOutcome<TaskPage<BlockedTaskRow>>>;
 export declare function queryTasks(input: Readonly<{

package/build/src/task/operations.js

@@ -1,5 +1,5 @@
 import { documentDiff } from "../markdown/diff.js";
-import { createTaskRelations, projectTaskBoardObservation, relationProblem, projectBlocked, projectRows, } from "./board.js";
+import { createTaskRelations, projectDetailFacts, projectTaskBoardObservation, relationProblem, projectBlocked, projectRows, } from "./board.js";
 import { parseTaskCreationDocument, serializeTaskDocument } from "./document.js";
 import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
 import { authorityPath, nukeTaskAuthority, readBoard, replaceAuthority, withTaskLocks, } from "./store.js";
@@ -185,7 +185,17 @@ function readScope(namespace, scope) {
 }
 export async function listTasks(world, namespace, selection, scope, limit = DEFAULT_TASK_LIMIT) {
     const selected = readScope(namespace, scope);
-    return { kind: "accepted", value: projectPage(projectRows((await readBoard(world)).board, selected, selection), limit) };
+    const board = (await readBoard(world)).board;
+    return { kind: "accepted", value: projectPage(projectRows(board, createTaskRelations(board), selected, selection), limit) };
+}
+export async function readTaskDetails(world, ids) {
+    const board = (await readBoard(world)).board;
+    const relations = createTaskRelations(board);
+    const details = ids.map((id) => projectDetailFacts(board, id, relations));
+    const missing = details.findIndex((detail) => detail === null);
+    return missing < 0
+        ? { kind: "accepted", value: details }
+        : { kind: "refused", refusal: { kind: "task-missing", taskId: ids[missing] } };
 }
 export async function readyTasks(world, namespace, scope, parent, limit = DEFAULT_TASK_LIMIT) {
     const selected = readScope(namespace, scope);
@@ -200,7 +210,7 @@ export async function readyTasks(world, namespace, scope, parent, limit = DEFAUL
         expression,
         limit: Math.max(1, board.tasks.size),
     }).rows;
-    const rows = selectedRows.map(({ parent: _parent, needs: _needs, blocks: _blocks, createdAt: _createdAt, updatedAt: _updatedAt, ...row }) => row);
+    const rows = selectedRows.map(({ parent: _parent, needs: _needs, blocks: _blocks, createdAt: _createdAt, ...row }) => row);
     return { kind: "accepted", value: projectPage(rows, limit) };
 }
 export async function blockedTasks(world, namespace, scope, parent, limit = DEFAULT_TASK_LIMIT) {
@@ -246,5 +256,6 @@ export async function observeTaskBoard(world) {
 }
 /** Internal identity catalog from one complete Task board read. */
 export async function observeTaskCatalogRows(world) {
-    return projectRows((await readBoard(world)).board, null, "all");
+    const board = (await readBoard(world)).board;
+    return projectRows(board, createTaskRelations(board), null, "all");
 }

package/build/src/task/query.js

@@ -1,5 +1,5 @@
 import { formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
-import { taskBlocked, taskDisposition, taskRef } from "./board.js";
+import { projectTaskRow, taskBlocked, taskDisposition, taskRef } from "./board.js";
 export const DEFAULT_TASK_LIMIT = 100;
 export const MAX_TASK_LIMIT = 1_000;
 export const TASK_RELATION_PREDICATE_FIELDS = ["under", "needs", "blocks"];
@@ -196,7 +196,7 @@ function matches(board, relations, task, expression, under) {
 }
 function row(board, relations, task) {
     return {
-        id: task.id, title: task.title, state: task.state, priority: task.priority, disposition: taskDisposition(board, task),
+        ...projectTaskRow(board, relations, task),
         parent: task.parent,
         needs: task.needs.map((need) => taskRef(board, need)),
         blocks: relations.blocks(task.id),

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

@@ -5,6 +5,7 @@ export type BoardSnapshot = Readonly<{
     board: TaskBoard;
     bytes: ReadonlyMap<TaskId, Uint8Array>;
 }>;
+export declare const DEFAULT_TASK_LOCK_TIMEOUT_MS = 3000;
 export declare function readBoard(world: WorldRoot): Promise<BoardSnapshot>;
 export declare function replaceAuthority(input: Readonly<{
     path: string;
@@ -16,6 +17,7 @@ export declare function withTaskLocks<T>(input: Readonly<{
     world: WorldRoot;
     allocation: boolean;
     ids: readonly TaskId[];
+    timeoutMs?: number;
     signal?: AbortSignal;
 }>, action: () => Promise<T>): Promise<T | "busy">;
 export declare function authorityPath(world: WorldRoot, id: TaskId): string;