mancode 0.6.3 → 0.6.5

package/dist/chunk-WRBNOPFA.js

@@ -0,0 +1,1235 @@
+// src/context/ids.ts
+import { randomBytes } from "crypto";
+var CROCKFORD_BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ULID_PATTERN = /^[0-7][0-9A-HJKMNPQRSTVWXYZ]{25}$/;
+var MAX_ULID_TIMESTAMP = 2 ** 48 - 1;
+function isUlid(value) {
+  return typeof value === "string" && ULID_PATTERN.test(value);
+}
+function assertUlid(value, label = "ULID") {
+  if (!isUlid(value)) {
+    throw new Error(`${label} must be a canonical ULID`);
+  }
+}
+function createUlid(now = Date.now(), entropy = randomBytes(10)) {
+  if (!Number.isSafeInteger(now) || now < 0 || now > MAX_ULID_TIMESTAMP) {
+    throw new Error("ULID timestamp must fit in 48 bits");
+  }
+  if (entropy.length !== 10) {
+    throw new Error("ULID entropy must contain exactly 10 bytes");
+  }
+  const timestamp = encodeBase32(BigInt(now), 10);
+  const random = encodeBase32(
+    BigInt(`0x${Buffer.from(entropy).toString("hex")}`),
+    16
+  );
+  return `${timestamp}${random}`;
+}
+function encodeBase32(value, length) {
+  let remaining = value;
+  let encoded = "";
+  for (let index = 0; index < length; index += 1) {
+    encoded = `${CROCKFORD_BASE32[Number(remaining & 31n)]}${encoded}`;
+    remaining >>= 5n;
+  }
+  if (remaining !== 0n) {
+    throw new Error("value does not fit in requested base32 length");
+  }
+  return encoded;
+}
+
+// src/context/validation.ts
+function isRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function assertRecord(value, label) {
+  if (!isRecord(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+}
+function assertKnownKeys(value, allowedKeys, label) {
+  const allowed = new Set(allowedKeys);
+  const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+  if (unknown.length > 0) {
+    throw new Error(
+      `${label} contains unknown field(s): ${unknown.join(", ")}`
+    );
+  }
+}
+
+// src/context/task-ref.ts
+var TASK_REF_PATTERN = /^(local|shared):([0-7][0-9A-HJKMNPQRSTVWXYZ]{25})$/;
+function formatTaskRef(taskRef) {
+  assertTaskRef(taskRef);
+  return `${taskRef.namespace}:${taskRef.taskId}`;
+}
+function parseTaskRef(input) {
+  if (typeof input !== "string") {
+    throw new Error("TaskRef must be a string in namespace:ULID form");
+  }
+  const match = TASK_REF_PATTERN.exec(input);
+  if (!match) {
+    throw new Error("TaskRef must use local:<ULID> or shared:<ULID>");
+  }
+  return {
+    namespace: match[1],
+    taskId: match[2]
+  };
+}
+function parseTaskRefValue(value) {
+  assertRecord(value, "TaskRef");
+  assertKnownKeys(value, ["namespace", "taskId"], "TaskRef");
+  if (value.namespace !== "local" && value.namespace !== "shared") {
+    throw new Error("TaskRef namespace must be local or shared");
+  }
+  assertUlid(value.taskId, "TaskRef taskId");
+  return {
+    namespace: value.namespace,
+    taskId: value.taskId
+  };
+}
+function assertTaskRef(value) {
+  parseTaskRefValue(value);
+}
+function sameTaskRef(left, right) {
+  return left.namespace === right.namespace && left.taskId === right.taskId;
+}
+
+// src/runtime/entity-home-store.ts
+import path from "path";
+function resolveTaskEntityHomeStore(context, taskRef) {
+  const normalized = normalizeContext(context);
+  const task = parseTaskRefValue(taskRef);
+  return task.namespace === "local" ? localTaskHomeStore(normalized) : coordinationEntityHomeStore(normalized);
+}
+function resolveLocalEntityHomeStore(context) {
+  return localTaskHomeStore(normalizeContext(context));
+}
+function resolveCoordinationEntityHomeStore(context) {
+  return coordinationEntityHomeStore(normalizeContext(context));
+}
+function operationDirectory(store) {
+  return path.join(store.root, "operations");
+}
+function reservationDirectory(store) {
+  return path.join(store.root, "reservations");
+}
+function lockDirectory(store) {
+  return path.join(store.root, "locks");
+}
+function claimDirectory(store) {
+  assertCoordinationStore(store, "claim");
+  return path.join(store.root, "claims");
+}
+function handoffDirectory(store) {
+  assertCoordinationStore(store, "handoff");
+  return path.join(store.root, "handoffs");
+}
+function taskHeadDirectory(store) {
+  assertCoordinationStore(store, "task head fence");
+  return path.join(store.root, "task-heads");
+}
+function normalizeContext(context) {
+  assertUlid(context.workspaceId, "entity home store workspaceId");
+  assertUlid(context.checkoutId, "entity home store checkoutId");
+  if (typeof context.projectRoot !== "string" || !context.projectRoot.trim()) {
+    throw new Error("entity home store projectRoot is required");
+  }
+  if (context.gitCommonDir === null) {
+    if (context.repositoryBindingId !== null) {
+      assertUlid(
+        context.repositoryBindingId,
+        "entity home store repositoryBindingId"
+      );
+    }
+    return {
+      ...context,
+      projectRoot: path.resolve(context.projectRoot),
+      gitCommonDir: null
+    };
+  }
+  if (typeof context.gitCommonDir !== "string" || !context.gitCommonDir.trim()) {
+    throw new Error("entity home store gitCommonDir must be a path or null");
+  }
+  if (context.repositoryBindingId === null) {
+    throw new Error(
+      "git coordination requires an entity home store repositoryBindingId"
+    );
+  }
+  assertUlid(
+    context.repositoryBindingId,
+    "entity home store repositoryBindingId"
+  );
+  return {
+    ...context,
+    projectRoot: path.resolve(context.projectRoot),
+    gitCommonDir: path.resolve(context.gitCommonDir)
+  };
+}
+function localTaskHomeStore(context) {
+  return {
+    kind: "checkout_local",
+    storeId: `checkout:${context.checkoutId}:${context.workspaceId}`,
+    root: path.join(context.projectRoot, ".mancode", "local", "runtime"),
+    workspaceId: context.workspaceId,
+    checkoutId: context.checkoutId,
+    repositoryBindingId: context.repositoryBindingId
+  };
+}
+function coordinationEntityHomeStore(context) {
+  if (context.gitCommonDir === null) {
+    return {
+      kind: "non_git_shared",
+      storeId: `non-git:${context.workspaceId}`,
+      root: path.join(
+        context.projectRoot,
+        ".mancode",
+        "runtime",
+        "non-git",
+        context.workspaceId
+      ),
+      workspaceId: context.workspaceId,
+      checkoutId: null,
+      repositoryBindingId: context.repositoryBindingId
+    };
+  }
+  if (context.repositoryBindingId === null) {
+    throw new Error("git coordination requires a repositoryBindingId");
+  }
+  return {
+    kind: "workspace_common_dir",
+    storeId: `workspace:${context.repositoryBindingId}:${context.workspaceId}`,
+    root: path.join(
+      context.gitCommonDir,
+      "mancode",
+      "workspaces",
+      context.workspaceId
+    ),
+    workspaceId: context.workspaceId,
+    checkoutId: null,
+    repositoryBindingId: context.repositoryBindingId
+  };
+}
+function assertCoordinationStore(store, entity) {
+  if (store.kind === "checkout_local") {
+    throw new Error(
+      `${entity} requires a shared coordination entity home store`
+    );
+  }
+}
+
+// src/context/canonical.ts
+import { createHash } from "crypto";
+function canonicalizeJson(value, options = {}) {
+  return canonicalizeValue(value, options.numberPolicy ?? "safe-integer");
+}
+function digestCanonicalJson(value, options = {}) {
+  const canonical = canonicalizeJson(value, options);
+  return `sha256:${createHash("sha256").update(canonical, "utf8").digest("hex")}`;
+}
+function sortUtf8StringSet(values) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    assertCanonicalString(value, "set item");
+    unique.add(value);
+  }
+  return [...unique].sort(
+    (left, right) => Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"))
+  );
+}
+function canonicalizeValue(value, numberPolicy) {
+  if (value === null) return "null";
+  if (typeof value === "string") {
+    assertCanonicalString(value, "string");
+    return JSON.stringify(value);
+  }
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || Object.is(value, -0)) {
+      throw new Error(
+        "canonical JSON numbers must be finite and must not be negative zero"
+      );
+    }
+    if (numberPolicy === "safe-integer" && !Number.isSafeInteger(value)) {
+      throw new Error(
+        "canonical JSON numbers must be safe integers for this schema"
+      );
+    }
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    assertCanonicalArray(value);
+    return `[${value.map((item) => canonicalizeValue(item, numberPolicy)).join(",")}]`;
+  }
+  if (isPlainObject(value)) {
+    assertCanonicalObject(value);
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((key) => {
+      assertCanonicalString(key, "object key");
+      return `${JSON.stringify(key)}:${canonicalizeValue(value[key], numberPolicy)}`;
+    }).join(",")}}`;
+  }
+  throw new Error("canonical JSON only accepts plain JSON values");
+}
+function assertCanonicalArray(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Object.hasOwn(value, index)) {
+      throw new Error("canonical JSON arrays must not be sparse");
+    }
+  }
+  const ownKeys = Object.keys(value);
+  if (ownKeys.some((key) => !/^(0|[1-9]\d*)$/.test(key))) {
+    throw new Error("canonical JSON arrays must not have non-index properties");
+  }
+  if (Object.getOwnPropertyNames(value).some(
+    (key) => key !== "length" && !ownKeys.includes(key)
+  ) || Object.getOwnPropertySymbols(value).length > 0) {
+    throw new Error("canonical JSON arrays must not have hidden properties");
+  }
+}
+function assertCanonicalObject(value) {
+  const ownKeys = Object.keys(value);
+  if (Object.getOwnPropertyNames(value).some((key) => !ownKeys.includes(key)) || Object.getOwnPropertySymbols(value).length > 0) {
+    throw new Error("canonical JSON objects must not have hidden properties");
+  }
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function assertCanonicalString(value, label) {
+  if (value.includes("\0")) {
+    throw new Error(`canonical JSON ${label} must not contain NUL`);
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit < 55296 || codeUnit > 57343) continue;
+    const next = value.charCodeAt(index + 1);
+    const isHigh = codeUnit <= 56319;
+    const isLowNext = next >= 56320 && next <= 57343;
+    if (!isHigh || !isLowNext) {
+      throw new Error(
+        `canonical JSON ${label} must not contain a lone surrogate`
+      );
+    }
+    index += 1;
+  }
+}
+
+// src/team/policy.ts
+var V3_LAYOUT_VERSION = 3;
+function parseProjectConfig(value) {
+  assertRecord(value, "project config");
+  assertKnownKeys(
+    value,
+    [
+      "schemaVersion",
+      "revision",
+      "workspaceId",
+      "transport",
+      "lastOperationId",
+      "updatedAt"
+    ],
+    "project config"
+  );
+  if (value.schemaVersion !== 1) {
+    throw new Error("project config schemaVersion must be 1");
+  }
+  assertUlid(value.workspaceId, "project config workspaceId");
+  return {
+    schemaVersion: 1,
+    revision: parsePositiveInteger(value.revision, "project config revision"),
+    workspaceId: value.workspaceId,
+    transport: parseTransport(value.transport),
+    lastOperationId: parseUlidOrNull(
+      value.lastOperationId,
+      "project config lastOperationId"
+    ),
+    updatedAt: parseTimestamp(value.updatedAt, "project config updatedAt")
+  };
+}
+function parseTeamPolicy(value) {
+  assertRecord(value, "team policy");
+  assertKnownKeys(
+    value,
+    [
+      "schemaVersion",
+      "revision",
+      "workspaceId",
+      "policy",
+      "recentDays",
+      "defaultVisibility",
+      "shareConfirmedDecisions",
+      "retention",
+      "lastOperationId",
+      "updatedAt"
+    ],
+    "team policy"
+  );
+  if (value.schemaVersion !== 1) {
+    throw new Error("team policy schemaVersion must be 1");
+  }
+  assertUlid(value.workspaceId, "team policy workspaceId");
+  if (value.policy !== "on" && value.policy !== "off" && value.policy !== "auto") {
+    throw new Error("team policy policy is invalid");
+  }
+  if (value.defaultVisibility !== "local" && value.defaultVisibility !== "shared") {
+    throw new Error("team policy defaultVisibility is invalid");
+  }
+  if (typeof value.shareConfirmedDecisions !== "boolean") {
+    throw new Error("team policy shareConfirmedDecisions must be boolean");
+  }
+  return {
+    schemaVersion: 1,
+    revision: parsePositiveInteger(value.revision, "team policy revision"),
+    workspaceId: value.workspaceId,
+    policy: value.policy,
+    recentDays: parseNonNegativeInteger(
+      value.recentDays,
+      "team policy recentDays"
+    ),
+    defaultVisibility: value.defaultVisibility,
+    shareConfirmedDecisions: value.shareConfirmedDecisions,
+    retention: parseRetention(value.retention),
+    lastOperationId: parseUlidOrNull(
+      value.lastOperationId,
+      "team policy lastOperationId"
+    ),
+    updatedAt: parseTimestamp(value.updatedAt, "team policy updatedAt")
+  };
+}
+function projectConfigIdentityDigest(config) {
+  return digestCanonicalJson({
+    workspaceId: config.workspaceId,
+    configSchemaVersion: config.schemaVersion,
+    layoutVersion: V3_LAYOUT_VERSION
+  });
+}
+function projectConfigDigest(config) {
+  return digestCanonicalJson(parseProjectConfig(config));
+}
+function assertConfigPolicyConsistency(config, policy) {
+  if (config.workspaceId !== policy.workspaceId) {
+    throw new Error("project config and team policy workspaceId must match");
+  }
+}
+function assertProjectConfigTransition(previous, next, kind) {
+  assertConfigIdentityStable(previous, next);
+  assertRevisionIncrease(
+    previous.revision,
+    next.revision,
+    "project config revision"
+  );
+  const transportChanged = previous.transport.mode !== next.transport.mode || previous.transport.remote !== next.transport.remote || previous.transport.epoch !== next.transport.epoch;
+  if (transportChanged && kind === "ordinary") {
+    throw new Error(
+      "project config transport may only change through transport_set or transport_migrate"
+    );
+  }
+  if (!transportChanged && kind !== "ordinary") {
+    throw new Error(
+      "transport mutation requires a changed project config transport"
+    );
+  }
+  if (kind !== "ordinary" && next.transport.epoch !== previous.transport.epoch + 1) {
+    throw new Error(
+      "transport mutation must increase the authority epoch exactly once"
+    );
+  }
+}
+function assertTeamPolicyTransition(previous, next) {
+  if (previous.schemaVersion !== next.schemaVersion || previous.workspaceId !== next.workspaceId) {
+    throw new Error("team policy schemaVersion and workspaceId are immutable");
+  }
+  assertRevisionIncrease(
+    previous.revision,
+    next.revision,
+    "team policy revision"
+  );
+}
+function parseTransport(value) {
+  assertRecord(value, "project config transport");
+  assertKnownKeys(
+    value,
+    ["mode", "remote", "epoch"],
+    "project config transport"
+  );
+  if (value.mode !== "local" && value.mode !== "git-ref") {
+    throw new Error("project config transport mode is invalid");
+  }
+  const remote = parseNonEmptyStringOrNull(
+    value.remote,
+    "project config transport remote"
+  );
+  if (value.mode === "local" && remote !== null) {
+    throw new Error("local project config transport must not set a remote");
+  }
+  if (value.mode === "git-ref" && remote === null) {
+    throw new Error("git-ref project config transport requires a remote");
+  }
+  const epoch = value.epoch === void 0 ? 1 : parsePositiveInteger(value.epoch, "project config transport epoch");
+  return { mode: value.mode, remote, epoch };
+}
+function parseRetention(value) {
+  assertRecord(value, "team policy retention");
+  assertKnownKeys(
+    value,
+    ["localRawArtifactDays", "localCacheDays", "completedSessionDays"],
+    "team policy retention"
+  );
+  return {
+    localRawArtifactDays: parseNonNegativeInteger(
+      value.localRawArtifactDays,
+      "team policy retention localRawArtifactDays"
+    ),
+    localCacheDays: parseNonNegativeInteger(
+      value.localCacheDays,
+      "team policy retention localCacheDays"
+    ),
+    completedSessionDays: parseNonNegativeInteger(
+      value.completedSessionDays,
+      "team policy retention completedSessionDays"
+    )
+  };
+}
+function assertConfigIdentityStable(previous, next) {
+  if (previous.schemaVersion !== next.schemaVersion || previous.workspaceId !== next.workspaceId) {
+    throw new Error(
+      "project config schemaVersion and workspaceId are immutable"
+    );
+  }
+}
+function assertRevisionIncrease(previous, next, label) {
+  if (next !== previous + 1) {
+    throw new Error(`${label} must increase exactly once per mutation`);
+  }
+}
+function parsePositiveInteger(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return value;
+}
+function parseNonNegativeInteger(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+  return value;
+}
+function parseUlidOrNull(value, label) {
+  if (value === null) return null;
+  assertUlid(value, label);
+  return value;
+}
+function parseNonEmptyStringOrNull(value, label) {
+  if (value === null) return null;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${label} must be a non-empty string or null`);
+  }
+  return value;
+}
+function parseTimestamp(value, label) {
+  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+    throw new Error(`${label} must be an ISO timestamp`);
+  }
+  return value;
+}
+
+// src/runtime/project-runtime.ts
+import { execFile as execFileCallback } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { mkdir, readFile, realpath, rename, writeFile } from "fs/promises";
+import path2 from "path";
+import { promisify } from "util";
+
+// src/runtime/workspace-binding.ts
+var DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/;
+function parseWorkspaceBinding(value) {
+  assertRecord(value, "workspace binding");
+  assertKnownKeys(
+    value,
+    [
+      "schemaVersion",
+      "workspaceId",
+      "repositoryBindingId",
+      "projectPathFromWorktreeRoot",
+      "configSchemaVersion",
+      "configIdentityDigest",
+      "registeredAt"
+    ],
+    "workspace binding"
+  );
+  if (value.schemaVersion !== 1) {
+    throw new Error("workspace binding schemaVersion must be 1");
+  }
+  assertUlid(value.workspaceId, "workspace binding workspaceId");
+  assertUlid(
+    value.repositoryBindingId,
+    "workspace binding repositoryBindingId"
+  );
+  return {
+    schemaVersion: 1,
+    workspaceId: value.workspaceId,
+    repositoryBindingId: value.repositoryBindingId,
+    projectPathFromWorktreeRoot: parseProjectRelativePath(
+      value.projectPathFromWorktreeRoot
+    ),
+    configSchemaVersion: parsePositiveInteger2(
+      value.configSchemaVersion,
+      "workspace binding configSchemaVersion"
+    ),
+    configIdentityDigest: parseDigest(
+      value.configIdentityDigest,
+      "workspace binding configIdentityDigest"
+    ),
+    registeredAt: parseTimestamp2(
+      value.registeredAt,
+      "workspace binding registeredAt"
+    )
+  };
+}
+function parseCheckoutBinding(value) {
+  assertRecord(value, "checkout binding");
+  assertKnownKeys(
+    value,
+    [
+      "schemaVersion",
+      "workspaceId",
+      "repositoryBindingId",
+      "checkoutId",
+      "worktreeGitDirHash",
+      "projectRealpathHash",
+      "registeredAt",
+      "lastSeenAt"
+    ],
+    "checkout binding"
+  );
+  if (value.schemaVersion !== 1) {
+    throw new Error("checkout binding schemaVersion must be 1");
+  }
+  assertUlid(value.workspaceId, "checkout binding workspaceId");
+  assertUlid(value.repositoryBindingId, "checkout binding repositoryBindingId");
+  assertUlid(value.checkoutId, "checkout binding checkoutId");
+  return {
+    schemaVersion: 1,
+    workspaceId: value.workspaceId,
+    repositoryBindingId: value.repositoryBindingId,
+    checkoutId: value.checkoutId,
+    worktreeGitDirHash: parseDigest(
+      value.worktreeGitDirHash,
+      "checkout binding worktreeGitDirHash"
+    ),
+    projectRealpathHash: parseDigest(
+      value.projectRealpathHash,
+      "checkout binding projectRealpathHash"
+    ),
+    registeredAt: parseTimestamp2(
+      value.registeredAt,
+      "checkout binding registeredAt"
+    ),
+    lastSeenAt: parseTimestamp2(value.lastSeenAt, "checkout binding lastSeenAt")
+  };
+}
+function assertWorkspaceBindingMatchesConfig(binding, config) {
+  if (binding.workspaceId !== config.workspaceId || binding.configSchemaVersion !== config.schemaVersion || binding.configIdentityDigest !== projectConfigIdentityDigest(config)) {
+    throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+  }
+}
+function assertWorkspaceBindingCompatible(existing, candidate) {
+  if (existing.workspaceId !== candidate.workspaceId || existing.repositoryBindingId !== candidate.repositoryBindingId || existing.projectPathFromWorktreeRoot !== candidate.projectPathFromWorktreeRoot || existing.configSchemaVersion !== candidate.configSchemaVersion || existing.configIdentityDigest !== candidate.configIdentityDigest) {
+    throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+  }
+}
+function assertCheckoutBindingMatchesWorkspace(checkout, workspace) {
+  if (checkout.workspaceId !== workspace.workspaceId || checkout.repositoryBindingId !== workspace.repositoryBindingId) {
+    throw new Error("MANCODE_CHECKOUT_BINDING_MISMATCH");
+  }
+}
+function localCoordinationDomainId(repositoryBindingId, workspaceId) {
+  assertUlid(repositoryBindingId, "local coordination repositoryBindingId");
+  assertUlid(workspaceId, "local coordination workspaceId");
+  return `local:${repositoryBindingId}:${workspaceId}`;
+}
+function gitRefCoordinationDomainId(remoteIdentityHash, workspaceId, transportEpoch) {
+  parseDigest(remoteIdentityHash, "git-ref coordination remoteIdentityHash");
+  assertUlid(workspaceId, "git-ref coordination workspaceId");
+  if (typeof transportEpoch === "number") {
+    if (!Number.isSafeInteger(transportEpoch) || transportEpoch < 1) {
+      throw new Error(
+        "git-ref coordination transportEpoch must be a positive integer"
+      );
+    }
+  } else {
+    assertUlid(transportEpoch, "git-ref coordination transportEpoch");
+  }
+  return `git-ref:${remoteIdentityHash}:${workspaceId}:${transportEpoch}`;
+}
+function parseProjectRelativePath(value) {
+  if (typeof value !== "string" || value.includes("\0") || value.includes("\\")) {
+    throw new Error("workspace binding projectPathFromWorktreeRoot is invalid");
+  }
+  if (value === ".") return value;
+  if (!value || value.startsWith("/") || value.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new Error("workspace binding projectPathFromWorktreeRoot is invalid");
+  }
+  return value;
+}
+function parsePositiveInteger2(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return value;
+}
+function parseDigest(value, label) {
+  if (typeof value !== "string" || !DIGEST_PATTERN.test(value)) {
+    throw new Error(`${label} must be a sha256 digest`);
+  }
+  return value;
+}
+function parseTimestamp2(value, label) {
+  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+    throw new Error(`${label} must be an ISO timestamp`);
+  }
+  return value;
+}
+
+// src/runtime/project-runtime.ts
+var execFile = promisify(execFileCallback);
+var DIGEST_PATTERN2 = /^sha256:[a-f0-9]{64}$/;
+async function ensureProjectRuntimeContext(projectRoot, now = /* @__PURE__ */ new Date()) {
+  const root = path2.resolve(projectRoot);
+  const config = await readProjectConfig(root);
+  const git = await inspectGitCheckout(root);
+  const timestamp = now.toISOString();
+  if (git === null) {
+    const checkout2 = await ensureRuntimeCheckoutRecord(root, {
+      workspaceId: config.workspaceId,
+      repositoryBindingId: null,
+      now: timestamp
+    });
+    return runtimeContext(
+      root,
+      config.workspaceId,
+      checkout2.checkoutId,
+      null,
+      null
+    );
+  }
+  const repository = await ensureRepositoryRuntimeBinding(
+    git.commonDir,
+    timestamp
+  );
+  const workspace = await ensureWorkspaceBinding(
+    root,
+    git,
+    repository.repositoryBindingId,
+    config,
+    timestamp
+  );
+  const checkout = await ensureRuntimeCheckoutRecord(root, {
+    workspaceId: config.workspaceId,
+    repositoryBindingId: repository.repositoryBindingId,
+    now: timestamp
+  });
+  await ensureCheckoutBinding(root, git, workspace, checkout, timestamp);
+  return runtimeContext(
+    root,
+    config.workspaceId,
+    checkout.checkoutId,
+    repository.repositoryBindingId,
+    git.commonDir
+  );
+}
+async function readProjectRuntimeContext(projectRoot) {
+  const root = path2.resolve(projectRoot);
+  const config = await readProjectConfig(root);
+  const checkout = await readRuntimeCheckoutRecord(root);
+  if (checkout === null || checkout.workspaceId !== config.workspaceId) {
+    throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+  }
+  const git = await inspectGitCheckout(root);
+  if (git === null) {
+    if (checkout.repositoryBindingId !== null) {
+      throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+    }
+    return runtimeContext(
+      root,
+      config.workspaceId,
+      checkout.checkoutId,
+      null,
+      null
+    );
+  }
+  if (checkout.repositoryBindingId === null) {
+    throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+  }
+  const repository = await readRepositoryRuntimeBinding(git.commonDir);
+  if (repository === null || repository.repositoryBindingId !== checkout.repositoryBindingId) {
+    throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+  }
+  const workspace = await readWorkspaceBinding(
+    git.commonDir,
+    config.workspaceId
+  );
+  if (workspace === null) throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+  assertWorkspaceBindingMatchesConfig(workspace, config);
+  assertCheckoutBindingMatchesWorkspace(
+    await requireCheckoutBinding(root),
+    workspace
+  );
+  return runtimeContext(
+    root,
+    config.workspaceId,
+    checkout.checkoutId,
+    checkout.repositoryBindingId,
+    git.commonDir
+  );
+}
+async function readCheckoutCodeHead(projectRoot) {
+  const root = path2.resolve(projectRoot);
+  const output = await runGit(root, ["rev-parse", "HEAD"]);
+  return output === null || !output.trim() ? null : output.trim();
+}
+async function readCheckoutBranch(projectRoot) {
+  const root = path2.resolve(projectRoot);
+  const output = await runGit(root, ["symbolic-ref", "--short", "-q", "HEAD"]);
+  return output === null || !output.trim() ? null : output.trim();
+}
+function runtimeCheckoutRecordPath(projectRoot) {
+  return path2.join(
+    path2.resolve(projectRoot),
+    ".mancode",
+    "local",
+    "runtime",
+    "checkout.json"
+  );
+}
+function runtimeCheckoutBindingPath(projectRoot) {
+  return path2.join(
+    path2.resolve(projectRoot),
+    ".mancode",
+    "local",
+    "runtime",
+    "checkout-binding.json"
+  );
+}
+function repositoryRuntimeBindingPath(gitCommonDir) {
+  return path2.join(path2.resolve(gitCommonDir), "mancode", "repository.json");
+}
+function workspaceRuntimeBindingPath(gitCommonDir, workspaceId) {
+  assertUlid(workspaceId, "workspace runtime binding workspaceId");
+  return path2.join(
+    path2.resolve(gitCommonDir),
+    "mancode",
+    "workspaces",
+    workspaceId,
+    "binding.json"
+  );
+}
+function parseRuntimeCheckoutRecord(value) {
+  assertRecord(value, "runtime checkout record");
+  assertKnownKeys(
+    value,
+    [
+      "schemaVersion",
+      "workspaceId",
+      "checkoutId",
+      "repositoryBindingId",
+      "registeredAt",
+      "lastSeenAt"
+    ],
+    "runtime checkout record"
+  );
+  if (value.schemaVersion !== 1) {
+    throw new Error("runtime checkout record schemaVersion must be 1");
+  }
+  assertUlid(value.workspaceId, "runtime checkout record workspaceId");
+  assertUlid(value.checkoutId, "runtime checkout record checkoutId");
+  if (value.repositoryBindingId !== null) {
+    assertUlid(
+      value.repositoryBindingId,
+      "runtime checkout record repositoryBindingId"
+    );
+  }
+  return {
+    schemaVersion: 1,
+    workspaceId: value.workspaceId,
+    checkoutId: value.checkoutId,
+    repositoryBindingId: value.repositoryBindingId,
+    registeredAt: parseTimestamp3(
+      value.registeredAt,
+      "runtime checkout record registeredAt"
+    ),
+    lastSeenAt: parseTimestamp3(
+      value.lastSeenAt,
+      "runtime checkout record lastSeenAt"
+    )
+  };
+}
+function parseRepositoryRuntimeBinding(value) {
+  assertRecord(value, "repository runtime binding");
+  assertKnownKeys(
+    value,
+    ["schemaVersion", "repositoryBindingId", "commonDirHash", "createdAt"],
+    "repository runtime binding"
+  );
+  if (value.schemaVersion !== 1) {
+    throw new Error("repository runtime binding schemaVersion must be 1");
+  }
+  assertUlid(value.repositoryBindingId, "repository runtime binding ID");
+  return {
+    schemaVersion: 1,
+    repositoryBindingId: value.repositoryBindingId,
+    commonDirHash: parseDigest2(
+      value.commonDirHash,
+      "repository runtime binding commonDirHash"
+    ),
+    createdAt: parseTimestamp3(
+      value.createdAt,
+      "repository runtime binding createdAt"
+    )
+  };
+}
+async function readProjectConfig(projectRoot) {
+  try {
+    return parseProjectConfig(
+      JSON.parse(
+        await readFile(
+          path2.join(projectRoot, ".mancode", "shared", "config.json"),
+          "utf8"
+        )
+      )
+    );
+  } catch (error) {
+    if (isNotFound(error))
+      throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+    if (error instanceof SyntaxError) {
+      throw new Error("MANCODE_CONTEXT_ENTITY_CORRUPT: shared/config.json");
+    }
+    throw error;
+  }
+}
+async function inspectGitCheckout(projectRoot) {
+  const [commonDirRaw, gitDirRaw, worktreeRootRaw] = await Promise.all([
+    runGit(projectRoot, [
+      "rev-parse",
+      "--path-format=absolute",
+      "--git-common-dir"
+    ]),
+    runGit(projectRoot, ["rev-parse", "--path-format=absolute", "--git-dir"]),
+    runGit(projectRoot, [
+      "rev-parse",
+      "--path-format=absolute",
+      "--show-toplevel"
+    ])
+  ]);
+  if (commonDirRaw === null || gitDirRaw === null || worktreeRootRaw === null) {
+    return null;
+  }
+  const [commonDir, gitDir, worktreeRoot] = await Promise.all([
+    realpath(resolveGitPath(projectRoot, commonDirRaw.trim())),
+    realpath(resolveGitPath(projectRoot, gitDirRaw.trim())),
+    realpath(resolveGitPath(projectRoot, worktreeRootRaw.trim()))
+  ]);
+  return { commonDir, gitDir, worktreeRoot };
+}
+async function ensureRepositoryRuntimeBinding(gitCommonDir, now) {
+  const target = repositoryRuntimeBindingPath(gitCommonDir);
+  const existing = await readRepositoryRuntimeBinding(gitCommonDir);
+  const commonDirHash = digestPath(gitCommonDir);
+  if (existing !== null) {
+    if (existing.commonDirHash !== commonDirHash) {
+      throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+    }
+    return existing;
+  }
+  const candidate = parseRepositoryRuntimeBinding({
+    schemaVersion: 1,
+    repositoryBindingId: createUlid(),
+    commonDirHash,
+    createdAt: now
+  });
+  return writeExclusiveOrRead(
+    target,
+    candidate,
+    parseRepositoryRuntimeBinding,
+    (stored, intended) => stored.commonDirHash === intended.commonDirHash,
+    "MANCODE_WORKSPACE_BINDING_MISMATCH"
+  );
+}
+async function ensureWorkspaceBinding(projectRoot, git, repositoryBindingId, config, now) {
+  const projectPathFromWorktreeRoot = relativeProjectPath(
+    await realpath(git.worktreeRoot),
+    await realpath(projectRoot)
+  );
+  const candidate = parseWorkspaceBinding({
+    schemaVersion: 1,
+    workspaceId: config.workspaceId,
+    repositoryBindingId,
+    projectPathFromWorktreeRoot,
+    configSchemaVersion: config.schemaVersion,
+    configIdentityDigest: projectConfigIdentityDigest(config),
+    registeredAt: now
+  });
+  const target = workspaceRuntimeBindingPath(git.commonDir, config.workspaceId);
+  const existing = await readWorkspaceBinding(
+    git.commonDir,
+    config.workspaceId
+  );
+  if (existing !== null) {
+    assertWorkspaceBindingCompatible(existing, candidate);
+    assertWorkspaceBindingMatchesConfig(existing, config);
+    return existing;
+  }
+  return writeExclusiveOrRead(
+    target,
+    candidate,
+    parseWorkspaceBinding,
+    (stored, intended) => {
+      try {
+        assertWorkspaceBindingCompatible(stored, intended);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    "MANCODE_WORKSPACE_BINDING_MISMATCH"
+  );
+}
+async function ensureRuntimeCheckoutRecord(projectRoot, input) {
+  const target = runtimeCheckoutRecordPath(projectRoot);
+  const existing = await readRuntimeCheckoutRecord(projectRoot);
+  if (existing !== null) {
+    if (existing.workspaceId !== input.workspaceId || existing.repositoryBindingId !== input.repositoryBindingId) {
+      throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+    }
+    const updated = { ...existing, lastSeenAt: input.now };
+    await writeAtomic(target, updated);
+    return updated;
+  }
+  const candidate = parseRuntimeCheckoutRecord({
+    schemaVersion: 1,
+    workspaceId: input.workspaceId,
+    checkoutId: createUlid(),
+    repositoryBindingId: input.repositoryBindingId,
+    registeredAt: input.now,
+    lastSeenAt: input.now
+  });
+  return writeExclusiveOrRead(
+    target,
+    candidate,
+    parseRuntimeCheckoutRecord,
+    (stored, intended) => stored.workspaceId === intended.workspaceId && stored.repositoryBindingId === intended.repositoryBindingId,
+    "MANCODE_WORKSPACE_BINDING_MISMATCH"
+  );
+}
+async function ensureCheckoutBinding(projectRoot, git, workspace, checkout, now) {
+  if (checkout.repositoryBindingId === null) {
+    throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+  }
+  const candidate = parseCheckoutBinding({
+    schemaVersion: 1,
+    workspaceId: workspace.workspaceId,
+    repositoryBindingId: workspace.repositoryBindingId,
+    checkoutId: checkout.checkoutId,
+    worktreeGitDirHash: digestPath(git.gitDir),
+    projectRealpathHash: digestPath(await realpath(projectRoot)),
+    registeredAt: checkout.registeredAt,
+    lastSeenAt: now
+  });
+  const target = runtimeCheckoutBindingPath(projectRoot);
+  const existing = await readCheckoutBinding(projectRoot);
+  if (existing !== null) {
+    assertCheckoutBindingMatchesWorkspace(existing, workspace);
+    if (existing.checkoutId !== candidate.checkoutId || existing.worktreeGitDirHash !== candidate.worktreeGitDirHash || existing.projectRealpathHash !== candidate.projectRealpathHash) {
+      throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+    }
+    const updated = { ...existing, lastSeenAt: now };
+    await writeAtomic(target, updated);
+    return updated;
+  }
+  return writeExclusiveOrRead(
+    target,
+    candidate,
+    parseCheckoutBinding,
+    (stored, intended) => stored.checkoutId === intended.checkoutId && stored.worktreeGitDirHash === intended.worktreeGitDirHash && stored.projectRealpathHash === intended.projectRealpathHash,
+    "MANCODE_WORKSPACE_BINDING_MISMATCH"
+  );
+}
+async function readRuntimeCheckoutRecord(projectRoot) {
+  return readJsonOrNull(
+    runtimeCheckoutRecordPath(projectRoot),
+    parseRuntimeCheckoutRecord
+  );
+}
+async function requireCheckoutBinding(projectRoot) {
+  const binding = await readCheckoutBinding(projectRoot);
+  if (binding === null) throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+  return binding;
+}
+async function readCheckoutBinding(projectRoot) {
+  return readJsonOrNull(
+    runtimeCheckoutBindingPath(projectRoot),
+    parseCheckoutBinding
+  );
+}
+async function readRepositoryRuntimeBinding(gitCommonDir) {
+  return readJsonOrNull(
+    repositoryRuntimeBindingPath(gitCommonDir),
+    parseRepositoryRuntimeBinding
+  );
+}
+async function readWorkspaceBinding(gitCommonDir, workspaceId) {
+  return readJsonOrNull(
+    workspaceRuntimeBindingPath(gitCommonDir, workspaceId),
+    parseWorkspaceBinding
+  );
+}
+function runtimeContext(projectRoot, workspaceId, checkoutId, repositoryBindingId, gitCommonDir) {
+  const entityHomeStoreContext = {
+    projectRoot,
+    workspaceId,
+    checkoutId,
+    repositoryBindingId,
+    gitCommonDir
+  };
+  resolveCoordinationEntityHomeStore(entityHomeStoreContext);
+  return {
+    projectRoot,
+    workspaceId,
+    checkoutId,
+    repositoryBindingId,
+    gitCommonDir,
+    entityHomeStoreContext
+  };
+}
+async function runGit(cwd, args) {
+  try {
+    const { stdout } = await execFile("git", args, {
+      cwd,
+      encoding: "utf8",
+      timeout: 5e3,
+      maxBuffer: 64 * 1024
+    });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+function resolveGitPath(projectRoot, value) {
+  if (!value || value.includes("\0")) {
+    throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+  }
+  return path2.isAbsolute(value) ? path2.resolve(value) : path2.resolve(projectRoot, value);
+}
+function relativeProjectPath(worktreeRoot, projectRoot) {
+  const relative = path2.relative(worktreeRoot, projectRoot);
+  if (relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative)) {
+    throw new Error("MANCODE_WORKSPACE_BINDING_MISMATCH");
+  }
+  return relative === "." || relative === "" ? "." : relative.split(path2.sep).join("/");
+}
+function digestPath(value) {
+  return `sha256:${createHash2("sha256").update(value, "utf8").digest("hex")}`;
+}
+async function writeExclusiveOrRead(target, value, parser, compatible, conflictCode) {
+  await mkdir(path2.dirname(target), { recursive: true });
+  try {
+    await writeFile(target, serialize(value), { encoding: "utf8", flag: "wx" });
+    return value;
+  } catch (error) {
+    if (!isAlreadyExists(error)) throw error;
+    const existing = await readJsonOrNull(target, parser);
+    if (existing !== null && compatible(existing, value)) return existing;
+    throw new Error(conflictCode);
+  }
+}
+async function writeAtomic(target, value) {
+  await mkdir(path2.dirname(target), { recursive: true });
+  const temporary = path2.join(
+    path2.dirname(target),
+    `.${path2.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  );
+  await writeFile(temporary, serialize(value), {
+    encoding: "utf8",
+    flag: "wx"
+  });
+  await rename(temporary, target);
+}
+async function readJsonOrNull(target, parser) {
+  try {
+    return parser(JSON.parse(await readFile(target, "utf8")));
+  } catch (error) {
+    if (isNotFound(error)) return null;
+    if (error instanceof SyntaxError) {
+      throw new Error("MANCODE_WORKSPACE_BINDING_CORRUPT");
+    }
+    throw error;
+  }
+}
+function parseDigest2(value, label) {
+  if (typeof value !== "string" || !DIGEST_PATTERN2.test(value)) {
+    throw new Error(`${label} must be a sha256 digest`);
+  }
+  return value;
+}
+function parseTimestamp3(value, label) {
+  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+    throw new Error(`${label} must be an ISO timestamp`);
+  }
+  return value;
+}
+function serialize(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isAlreadyExists(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+
+export {
+  isUlid,
+  assertUlid,
+  createUlid,
+  assertRecord,
+  assertKnownKeys,
+  formatTaskRef,
+  parseTaskRef,
+  parseTaskRefValue,
+  sameTaskRef,
+  resolveTaskEntityHomeStore,
+  resolveLocalEntityHomeStore,
+  resolveCoordinationEntityHomeStore,
+  operationDirectory,
+  reservationDirectory,
+  lockDirectory,
+  claimDirectory,
+  handoffDirectory,
+  taskHeadDirectory,
+  canonicalizeJson,
+  digestCanonicalJson,
+  sortUtf8StringSet,
+  parseProjectConfig,
+  parseTeamPolicy,
+  projectConfigDigest,
+  assertConfigPolicyConsistency,
+  assertProjectConfigTransition,
+  assertTeamPolicyTransition,
+  localCoordinationDomainId,
+  gitRefCoordinationDomainId,
+  ensureProjectRuntimeContext,
+  readProjectRuntimeContext,
+  readCheckoutCodeHead,
+  readCheckoutBranch
+};
+//# sourceMappingURL=chunk-WRBNOPFA.js.map