overlane 0.1.112 → 0.1.114

package/dist/overlane.mjs

@@ -21308,6 +21308,74 @@ var init_identity = __esm({
   }
 });
 
+// ../contracts/src/task-priority.ts
+var TASK_PRIORITIES, TaskPriority, TASK_ORIGINS, TaskOrigin, taskQueuePaths, RequestId2, PrioritiseRequest, PrioritiseResult, QueueEntry, TaskQueue, NextTask, TASK_ENFORCEMENT, TaskEnforcement, TaskPolicy, SetTaskPolicyRequest;
+var init_task_priority = __esm({
+  "../contracts/src/task-priority.ts"() {
+    "use strict";
+    init_zod();
+    init_common();
+    init_executor();
+    init_task_api();
+    init_task_contract();
+    TASK_PRIORITIES = ["P0", "P1", "P2", "P3"];
+    TaskPriority = external_exports.enum(TASK_PRIORITIES);
+    TASK_ORIGINS = ["user", "plan", "agent", "system"];
+    TaskOrigin = external_exports.enum(TASK_ORIGINS);
+    taskQueuePaths = {
+      base: (tenantId, projectId) => `/v1/tenants/${encodeURIComponent(tenantId)}/projects/${encodeURIComponent(projectId)}/queue`,
+      next: (tenantId, projectId) => `${taskQueuePaths.base(tenantId, projectId)}/next`,
+      policy: (tenantId, projectId) => `${taskQueuePaths.base(tenantId, projectId)}/policy`,
+      prioritise: (tenantId, projectId, taskId) => `${taskQueuePaths.base(tenantId, projectId)}/${encodeURIComponent(taskId)}/prioritise`
+    };
+    RequestId2 = external_exports.string().min(8).max(128);
+    PrioritiseRequest = external_exports.object({
+      requestId: RequestId2,
+      priority: TaskPriority,
+      top: external_exports.boolean().default(false),
+      /** Who asked for the work; recorded the first time a task is ranked. */
+      origin: TaskOrigin.default("agent"),
+      reason: external_exports.string().min(1).max(300).optional(),
+      /** The task this one displaces; the ledger records `task.preempted`. */
+      preempts: TaskId.optional(),
+      executor: Executor
+    }).strict();
+    PrioritiseResult = external_exports.object({
+      taskId: TaskId,
+      priority: TaskPriority,
+      rank: external_exports.number().int(),
+      origin: TaskOrigin,
+      previous: external_exports.object({ priority: TaskPriority, rank: external_exports.number().int() }).strict().nullable(),
+      changed: external_exports.boolean()
+    }).strict();
+    QueueEntry = external_exports.object({
+      taskId: TaskId,
+      title: external_exports.string(),
+      state: TaskState,
+      pauseReason: PauseReason.optional(),
+      priority: TaskPriority,
+      rank: external_exports.number().int(),
+      origin: TaskOrigin,
+      version: external_exports.number().int().positive()
+    }).strict();
+    TaskQueue = external_exports.object({ tasks: external_exports.array(QueueEntry) }).strict();
+    NextTask = external_exports.object({
+      task: QueueEntry.nullable(),
+      preempt: external_exports.boolean(),
+      why: external_exports.string()
+    }).strict();
+    TASK_ENFORCEMENT = ["required", "relaxed"];
+    TaskEnforcement = external_exports.enum(TASK_ENFORCEMENT);
+    TaskPolicy = external_exports.object({
+      enforcement: TaskEnforcement,
+      reason: external_exports.string().optional(),
+      changedBy: external_exports.string().optional(),
+      updatedAt: Timestamp.optional()
+    }).strict();
+    SetTaskPolicyRequest = external_exports.object({ requestId: RequestId2, enforcement: TaskEnforcement, reason: external_exports.string().min(1).max(300).optional(), executor: Executor }).strict().refine((request) => request.enforcement === "required" || request.reason !== void 0, { message: "relaxing the task requirement needs a reason", path: ["reason"] });
+  }
+});
+
 // ../contracts/src/index.ts
 var init_src = __esm({
   "../contracts/src/index.ts"() {
@@ -21325,6 +21393,7 @@ var init_src = __esm({
     init_release();
     init_kit();
     init_identity();
+    init_task_priority();
   }
 });
 
@@ -28659,7 +28728,7 @@ var require_dist = __commonJS({
 });
 
 // src/assets.ts
-import { basename as basename3, join as join21, resolve as resolve6 } from "node:path";
+import { basename as basename3, join as join22, resolve as resolve6 } from "node:path";
 import { fileURLToPath } from "node:url";
 function packageRoot(env = process.env) {
   const override = env["MVRX_PACKAGE_ROOT"];
@@ -28668,16 +28737,16 @@ function packageRoot(env = process.env) {
 }
 function assetDir(env = process.env) {
   const override = env["MVRX_ASSET_DIR"];
-  return override !== void 0 && override !== "" ? override : join21(packageRoot(env), "assets");
+  return override !== void 0 && override !== "" ? override : join22(packageRoot(env), "assets");
 }
 function assetFile(name2) {
-  return join21(assetDir(), basename3(name2));
+  return join22(assetDir(), basename3(name2));
 }
 var VERSION;
 var init_assets = __esm({
   "src/assets.ts"() {
     "use strict";
-    VERSION = true ? "0.1.112" : "0.0.0-dev";
+    VERSION = true ? "0.1.114" : "0.0.0-dev";
   }
 });
 
@@ -36606,7 +36675,7 @@ var init_treesitter = __esm({
 import { execFile } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { lstat, readFile as readFile4 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import { promisify } from "node:util";
 function shardKeyOf(shard) {
   return `sha256:${sha256Hex(Buffer.from(`${shard.path}\0${shard.contentHash}\0${shard.precision}`, "utf8"))}`;
@@ -36633,7 +36702,7 @@ async function mapLimit(items, limit, task) {
   return results;
 }
 async function hashRegularFile(repoRoot, path) {
-  const absolute = join22(repoRoot, path);
+  const absolute = join23(repoRoot, path);
   try {
     const stats = await lstat(absolute);
     if (!stats.isFile()) return null;
@@ -36671,7 +36740,7 @@ async function buildSnapshot(options) {
   const needParse = [...hashes.keys()].filter((path) => !byPath.has(path));
   const parsed = await mapLimit(needParse, 8, async (path) => {
     if (languageForPath(path) === null) return { path, shard: null };
-    const bytes = await readFile4(join22(options.repoRoot, path));
+    const bytes = await readFile4(join23(options.repoRoot, path));
     if (bytes.byteLength > MAX_PARSE_BYTES) return { path, shard: null };
     const hash2 = `sha256:${sha256Hex(bytes)}`;
     if (hash2 !== hashes.get(path)) throw new Error(`${path} changed while the snapshot was being built`);
@@ -36814,7 +36883,7 @@ var init_oidc = __esm({
 // ../index-builder/src/run.ts
 import { execFile as execFile2 } from "node:child_process";
 import { mkdir as mkdir3, readdir as readdir4, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join23, resolve as resolve7 } from "node:path";
+import { join as join24, resolve as resolve7 } from "node:path";
 import { parseArgs as parseArgs2 } from "node:util";
 import { promisify as promisify2 } from "node:util";
 async function git3(root, args2) {
@@ -36886,13 +36955,13 @@ ${USAGE}`);
   }
 }
 async function writeSnapshot(dir, built) {
-  await mkdir3(join23(dir, "shards"), { recursive: true });
-  for (const name2 of await readdir4(join23(dir, "shards"))) await rm2(join23(dir, "shards", name2));
-  await writeFile3(join23(dir, "manifest.json"), JSON.stringify(built.manifest, null, 2));
-  await writeFile3(join23(dir, "uncovered.json"), JSON.stringify(built.uncovered, null, 2));
+  await mkdir3(join24(dir, "shards"), { recursive: true });
+  for (const name2 of await readdir4(join24(dir, "shards"))) await rm2(join24(dir, "shards", name2));
+  await writeFile3(join24(dir, "manifest.json"), JSON.stringify(built.manifest, null, 2));
+  await writeFile3(join24(dir, "uncovered.json"), JSON.stringify(built.uncovered, null, 2));
   for (const shard of built.shards) {
     const name2 = shardKeyOf(shard).slice("sha256:".length);
-    await writeFile3(join23(dir, "shards", `${name2}.json`), JSON.stringify(shard));
+    await writeFile3(join24(dir, "shards", `${name2}.json`), JSON.stringify(shard));
   }
 }
 var execFileAsync2, USAGE, UsageError2, OPTIONS;
@@ -51730,7 +51799,7 @@ var init_cloud = __esm({
 // ../code-shim/src/git.ts
 import { execFileSync } from "node:child_process";
 import { existsSync as existsSync6 } from "node:fs";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 function git4(root, args2) {
   try {
     return execFileSync("git", args2, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024, timeout: 1e4 });
@@ -51792,7 +51861,7 @@ function readWorkingCopyState(root) {
   const head = headCommit2(root);
   const raw = git4(root, ["status", "--porcelain=v2", "-z", "--untracked-files=all"]);
   if (raw === null) return { head, dirty: /* @__PURE__ */ new Set(), deleted: /* @__PURE__ */ new Set(), renamed: /* @__PURE__ */ new Map() };
-  return { head, ...parseStatus(raw, (path) => existsSync6(join27(root, path))) };
+  return { head, ...parseStatus(raw, (path) => existsSync6(join28(root, path))) };
 }
 var init_git = __esm({
   "../code-shim/src/git.ts"() {
@@ -51803,16 +51872,16 @@ var init_git = __esm({
 // ../code-shim/src/config.ts
 import { readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 function configDir(env) {
-  const base2 = env["XDG_CONFIG_HOME"] ?? (process.platform === "win32" ? env["APPDATA"] : void 0) ?? join28(homedir2(), ".config");
-  return join28(base2, "mvrx-harness");
+  const base2 = env["XDG_CONFIG_HOME"] ?? (process.platform === "win32" ? env["APPDATA"] : void 0) ?? join29(homedir2(), ".config");
+  return join29(base2, "mvrx-harness");
 }
 function findToken2(env, serviceUrl, now) {
   const fromEnv = env["HARNESS_TOKEN"];
   if (fromEnv !== void 0 && fromEnv.length > 0) return fromEnv;
   try {
-    const file2 = JSON.parse(readFileSync7(join28(configDir(env), "credentials.json"), "utf8"));
+    const file2 = JSON.parse(readFileSync7(join29(configDir(env), "credentials.json"), "utf8"));
     const stored = file2[serviceUrl];
     if (stored === void 0 || typeof stored.accessToken !== "string" || stored.accessToken.length === 0) return null;
     if (typeof stored.expiresAt === "number" && stored.expiresAt <= now) return null;
@@ -51824,7 +51893,7 @@ function findToken2(env, serviceUrl, now) {
 function resolveCloudConfig(root, env, now) {
   let binding;
   try {
-    const parsed = ProjectBinding.safeParse(JSON.parse(readFileSync7(join28(root, ".harness", "project.json"), "utf8")));
+    const parsed = ProjectBinding.safeParse(JSON.parse(readFileSync7(join29(root, ".harness", "project.json"), "utf8")));
     if (!parsed.success) return null;
     binding = parsed.data;
   } catch {
@@ -52215,7 +52284,7 @@ var init_nav = __esm({
 
 // ../code-shim/src/edit.ts
 import { createHash as createHash8 } from "node:crypto";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "node:fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "node:fs";
 function lineStarts(text) {
   const starts = [0];
   for (let i2 = 0; i2 < text.length; i2 += 1) if (text[i2] === "\n") starts.push(i2 + 1);
@@ -52284,7 +52353,7 @@ ${args2.content.replace(/\n+$/, "")}`;
   const before = positionAt(next, changedStart);
   const after = positionAt(next, insertAt + inserted.length);
   const bytes = Buffer.from(next, "utf8");
-  writeFileSync7(absolute, bytes);
+  writeFileSync8(absolute, bytes);
   return {
     ok: true,
     path: args2.path,
@@ -52345,7 +52414,7 @@ async function renameSymbol(deps, args2) {
     let next = item.text;
     for (const offset of offsets) next = next.slice(0, offset) + args2.new_name + next.slice(offset + oldName.length);
     const bytes = Buffer.from(next, "utf8");
-    writeFileSync7(item.absolute, bytes);
+    writeFileSync8(item.absolute, bytes);
     filesChanged.push({ path: item.path, edits: offsets.length, sha256: sha2563(bytes) });
     edits += offsets.length;
   }
@@ -58229,6 +58298,239 @@ var runResumeCommand = defineCommand({
 });
 var runCommands = [runStartCommand, runNextCommand, runClaimCommand, runDecideCommand, runEndCommand, runStatusCommand, runPauseCommand, runResumeCommand];
 
+// ../cli/src/task/queue.ts
+init_src();
+init_zod();
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { mkdirSync as mkdirSync7, renameSync as renameSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname7, join as join21 } from "node:path";
+var TASK_POLICY_PATH = join21(".harness", "task-policy.json");
+function writePolicyFile(root, policy, nowMs) {
+  const path = join21(root, TASK_POLICY_PATH);
+  mkdirSync7(dirname7(path), { recursive: true });
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync6(temp, `${JSON.stringify({ enforcement: policy.enforcement, ...policy.reason === void 0 ? {} : { reason: policy.reason }, checkedAt: new Date(nowMs).toISOString() }, null, 2)}
+`);
+  renameSync5(temp, path);
+}
+var TaskNewResult = withDryRun(
+  external_exports.object({ taskId: external_exports.string(), version: external_exports.number(), state: external_exports.string(), holder: external_exports.string(), priority: TaskPriority, rank: external_exports.number(), next: external_exports.string() })
+);
+var TaskNextResult = external_exports.object({ task: NextTask.shape.task, preempt: external_exports.boolean(), why: external_exports.string(), command: external_exports.string().nullable() });
+var TaskQueueResult = TaskQueue;
+var TaskPrioritiseResult = withDryRun(external_exports.object({ ...PrioritiseResult.shape, next: external_exports.string() }));
+var TaskPolicyResult = external_exports.object({ enforcement: TaskEnforcement, reason: external_exports.string().optional(), changedBy: external_exports.string().optional(), updatedAt: external_exports.string().optional(), localFile: external_exports.string() });
+var TaskPolicySetResult = withDryRun(TaskPolicyResult);
+var requestId3 = () => `cli-${randomUUID4()}`;
+function priorityOf(value, fallback) {
+  const parsed = TaskPriority.safeParse(value ?? fallback);
+  if (!parsed.success) throw new UsageError(`--priority must be one of ${TASK_PRIORITIES.join(", ")}`);
+  return parsed.data;
+}
+var mcpExecutor = (name2) => name2 === "codex" ? "codex" : "claude-code";
+var commandFor = (entry) => `overlane task ${entry.state === "paused" ? "resume" : "start"} ${entry.taskId}`;
+async function taskNext(deps) {
+  const project = await connectedProject(deps, "task");
+  const call2 = serviceCall(deps, project.serviceUrl, project.token);
+  const current2 = readTaskState(project.root)?.taskId;
+  const query = `?executor=${mcpExecutor(detectExecutorName(deps.env))}${current2 === void 0 ? "" : `&current=${encodeURIComponent(current2)}`}`;
+  const next = await call2(NextTask, "GET", `${taskQueuePaths.next(project.binding.tenantId, project.binding.projectId)}${query}`);
+  if (next.task === null) {
+    say(deps, 'Nothing is ready or paused. Create work with `overlane task new "<title>"`.');
+    return { data: { ...next, command: null } };
+  }
+  const command = commandFor(next.task);
+  say(deps, `Next: ${next.task.taskId} (${next.task.priority}, ${next.task.state}) ${next.task.title}`);
+  say(deps, next.why);
+  if (next.preempt) say(deps, `This outranks your current task ${current2 ?? ""}: checkpoint it (\`overlane task checkpoint --summary "..." --next "..." --pause user\`), then run: ${command}`);
+  else say(deps, `Run: ${command}`);
+  return { data: { ...next, command } };
+}
+async function taskQueue(deps) {
+  const project = await connectedProject(deps, "task");
+  const queue = await serviceCall(deps, project.serviceUrl, project.token)(TaskQueue, "GET", taskQueuePaths.base(project.binding.tenantId, project.binding.projectId));
+  if (queue.tasks.length === 0) say(deps, "The queue is empty.");
+  for (const entry of queue.tasks) say(deps, `${entry.priority}  ${entry.taskId}  ${entry.state}${entry.pauseReason === void 0 ? "" : `/${entry.pauseReason}`}  ${entry.title}`);
+  return { data: queue };
+}
+async function prioritiseTask(deps, input2) {
+  if (input2.taskId === void 0) throw new UsageError("prioritise needs exactly one TASK_ID");
+  if (input2.priority === void 0) throw new UsageError("prioritise needs --priority P0|P1|P2|P3");
+  const priority = priorityOf(input2.priority, void 0);
+  const name2 = detectExecutorName(deps.env);
+  let request;
+  try {
+    request = PrioritiseRequest.parse({ requestId: requestId3(), priority, top: input2.top, origin: name2 === "terminal" ? "user" : "agent", ...input2.reason === void 0 ? {} : { reason: input2.reason }, executor: executorFor(name2) });
+  } catch (error62) {
+    throw new UsageError(String(error62));
+  }
+  if (input2.dryRun) {
+    const project2 = await offlineProject(deps, "task");
+    return planOutcome(deps, dryRunPlan({ service: project2.serviceUrl, requests: [{ method: "POST", path: taskQueuePaths.prioritise(project2.binding.tenantId, project2.binding.projectId, input2.taskId), body: request }] }));
+  }
+  const project = await connectedProject(deps, "task");
+  const result = await serviceCall(deps, project.serviceUrl, project.token)(PrioritiseResult, "POST", taskQueuePaths.prioritise(project.binding.tenantId, project.binding.projectId, input2.taskId), request);
+  say(deps, `${result.taskId} is now ${result.priority}${input2.top ? " and first in its priority" : ""} (rank ${result.rank}).${result.changed ? "" : " Nothing changed."}`);
+  return { data: { ...result, next: "overlane task next" } };
+}
+async function newTask(deps, input2) {
+  const title = input2.title.replace(/\s+/g, " ").trim();
+  if (title.length === 0) throw new UsageError('new needs a title: overlane task new "<title>"');
+  const priority = priorityOf(input2.priority, "P1");
+  const started = await startTask(deps, {
+    outcome: title,
+    criteria: input2.criteria.length > 0 ? input2.criteria : [`Complete: ${title}`],
+    paths: input2.paths.length > 0 ? input2.paths : ["**"],
+    checks: input2.checks,
+    dryRun: input2.dryRun
+  });
+  const data = started?.data;
+  if (data === void 0 || "dryRun" in data) return started;
+  const begun = data;
+  const project = await connectedProject(deps, "task");
+  const name2 = detectExecutorName(deps.env);
+  const request = PrioritiseRequest.parse({ requestId: requestId3(), priority, top: input2.top, origin: name2 === "terminal" ? "user" : "agent", executor: executorFor(name2) });
+  try {
+    const ranked = await serviceCall(deps, project.serviceUrl, project.token)(PrioritiseResult, "POST", taskQueuePaths.prioritise(project.binding.tenantId, project.binding.projectId, begun.taskId), request);
+    say(deps, `Ranked ${begun.taskId} ${ranked.priority}${input2.top ? " (first)" : ""}.`);
+    return { data: { taskId: begun.taskId, version: begun.version, state: begun.state, holder: begun.holder, priority: ranked.priority, rank: ranked.rank, next: begun.next } };
+  } catch (error62) {
+    warn(deps, `task ${begun.taskId} is claimed but could not be ranked (${error62 instanceof Error ? error62.message : String(error62)}); run \`overlane task prioritise ${begun.taskId} --priority ${priority}\``);
+    return { data: { taskId: begun.taskId, version: begun.version, state: begun.state, holder: begun.holder, priority: "P1", rank: 0, next: begun.next } };
+  }
+}
+async function showPolicy2(deps) {
+  const project = await connectedProject(deps, "task");
+  const policy = await serviceCall(deps, project.serviceUrl, project.token)(TaskPolicy, "GET", taskQueuePaths.policy(project.binding.tenantId, project.binding.projectId));
+  writePolicyFile(project.root, policy, deps.now());
+  say(deps, `Task requirement: ${policy.enforcement}${policy.reason === void 0 ? "" : ` (${policy.reason})`}.`);
+  return { data: { ...policy, localFile: TASK_POLICY_PATH } };
+}
+async function setPolicy(deps, input2) {
+  const enforcement = TaskEnforcement.safeParse(input2.enforcement);
+  if (!enforcement.success) throw new UsageError(`set needs ${TASK_ENFORCEMENT.join(" or ")}`);
+  const name2 = detectExecutorName(deps.env);
+  const parsed = SetTaskPolicyRequest.safeParse({ requestId: requestId3(), enforcement: enforcement.data, ...input2.reason === void 0 ? {} : { reason: input2.reason }, executor: executorFor(name2) });
+  if (!parsed.success) throw new UsageError(parsed.error.issues.map((issue2) => issue2.message).join("; "));
+  if (input2.dryRun) {
+    const project2 = await offlineProject(deps, "task");
+    return planOutcome(
+      deps,
+      dryRunPlan({
+        service: project2.serviceUrl,
+        requests: [{ method: "PUT", path: taskQueuePaths.policy(project2.binding.tenantId, project2.binding.projectId), body: parsed.data, note: "only a signed-in owner or admin may change it" }],
+        writes: [{ path: TASK_POLICY_PATH, action: "write", description: "this working copy's copy of the requirement (never committed)" }]
+      })
+    );
+  }
+  const project = await connectedProject(deps, "task");
+  const policy = await serviceCall(deps, project.serviceUrl, project.token)(TaskPolicy, "PUT", taskQueuePaths.policy(project.binding.tenantId, project.binding.projectId), parsed.data);
+  writePolicyFile(project.root, policy, deps.now());
+  say(deps, policy.enforcement === "required" ? "Every change now needs an active task." : `The task requirement is relaxed (${policy.reason ?? "no reason"}). It shows in the context packet and the event stream.`);
+  return { data: { ...policy, localFile: TASK_POLICY_PATH } };
+}
+async function startExisting(deps, taskId, dryRun) {
+  const resumed = await resumeTask(deps, { taskId, dryRun });
+  const data = resumed?.data;
+  if (data === void 0 || "dryRun" in data) return resumed;
+  return { data: { taskId: data.taskId, version: data.version, state: data.task.state, holder: data.holder, ...data.task.lease === void 0 ? {} : { leaseExpiresAt: data.task.lease.expiresAt }, next: "overlane task submit" } };
+}
+
+// ../cli/src/commands/queue.ts
+var common3 = { needsAuth: true, needsNetwork: true };
+var PRIORITIES = ["P0", "P1", "P2", "P3"];
+var taskNewCommand = defineCommand({
+  path: ["task", "new"],
+  summary: "Create a task from a title, claim it for this working copy and rank it",
+  description: "The quick way to get an active task, which every change needs. Creates a task with the title as its outcome (one default criterion and every path unless you pass --criterion and --path), claims it, and ranks it (default P1). Fails with exit 5 if this working copy already holds a task.",
+  args: [{ name: "title", required: true, variadic: true, description: "What the task must achieve" }],
+  flags: [
+    { name: "priority", type: "string", enum: PRIORITIES, default: "P1", description: "P0 is most urgent, P3 least" },
+    { name: "top", type: "boolean", description: "Put the task first within its priority" },
+    { name: "criterion", type: "string", multiple: true, value: "TEXT", description: "An acceptance criterion; repeat for more (default: the title)" },
+    { name: "path", type: "string", multiple: true, value: "GLOB", description: "A file pattern the task may change (default: everything)" },
+    { name: "check", type: "string", multiple: true, value: "ID:LEVEL", description: "A required check and its minimum evidence level, for example unit_tests:L2" }
+  ],
+  examples: ['overlane task new "Fix login redirect"', 'overlane task new "Hotfix the build" --priority P0 --top'],
+  effect: "write",
+  ...common3,
+  keywords: ["new task", "create task", "no active task", "blocked no task", "start work", "need a task", "begin", "quick task"],
+  result: TaskNewResult,
+  handler: async (inv) => newTask(inv.deps, {
+    title: inv.positionals.join(" "),
+    priority: textFlag(inv, "priority"),
+    top: boolFlag(inv, "top"),
+    criteria: listFlag(inv, "criterion"),
+    paths: listFlag(inv, "path"),
+    checks: listFlag(inv, "check"),
+    dryRun: inv.dryRun
+  })
+});
+var taskNextCommand = defineCommand({
+  path: ["task", "next"],
+  summary: "Show the task to work on next, ordered by priority, then rank, then plan order",
+  description: "Picks the best ready or paused task: P0 before P3, then rank, then milestone and dependency order. When this working copy holds a task and the next one outranks it, says so (preempt) and prints the commands to checkpoint and switch; the preempted task comes back through this command afterwards.",
+  examples: ["overlane task next"],
+  effect: "read",
+  ...common3,
+  keywords: ["what next", "next task", "priority", "what should i work on", "pick work", "resume after", "queue"],
+  result: TaskNextResult,
+  handler: async (inv) => taskNext(inv.deps)
+});
+var taskQueueCommand = defineCommand({
+  path: ["task", "queue"],
+  summary: "List open tasks in the order they will be worked",
+  description: "Lists ready, running, paused and blocked tasks by priority, then rank, then plan order, with each task's priority.",
+  examples: ["overlane task queue"],
+  effect: "read",
+  ...common3,
+  keywords: ["priority list", "ranking", "order", "backlog", "what is queued", "p0"],
+  result: TaskQueueResult,
+  handler: async (inv) => taskQueue(inv.deps)
+});
+var taskPrioritiseCommand = defineCommand({
+  path: ["task", "prioritise"],
+  summary: "Set a task's priority (P0 to P3) and optionally put it first",
+  description: "Re-ranks a task. Every change is a ledger event (`task.prioritised`). With --top the task goes first within its priority. A repeated identical call changes nothing.",
+  args: [{ name: "task-id", required: true, description: "The task to re-rank" }],
+  flags: [
+    { name: "priority", type: "string", required: true, enum: PRIORITIES, description: "P0 is most urgent, P3 least" },
+    { name: "top", type: "boolean", description: "Put the task first within its priority" },
+    { name: "reason", type: "string", value: "TEXT", description: "Why; kept in the event" }
+  ],
+  examples: ["overlane task prioritise task-7 --priority P0 --top", 'overlane task prioritise task-9 --priority P2 --reason "user said later"'],
+  effect: "write",
+  ...common3,
+  keywords: ["reprioritize", "reprioritise", "bump", "urgent", "move to top", "rank", "lower priority", "p0", "p1", "p2", "p3"],
+  result: TaskPrioritiseResult,
+  handler: async (inv) => prioritiseTask(inv.deps, { taskId: inv.positionals[0], priority: textFlag(inv, "priority"), top: boolFlag(inv, "top"), reason: textFlag(inv, "reason"), dryRun: inv.dryRun })
+});
+var taskPolicyCommand = defineCommand({
+  path: ["task", "policy"],
+  summary: "Show whether changes need an active task, and refresh this working copy's copy",
+  description: "Reads the project's task requirement (default `required`: edits and mutating shell commands are refused without an active task) and writes it to .harness/task-policy.json for the hooks.",
+  examples: ["overlane task policy"],
+  effect: "read",
+  ...common3,
+  keywords: ["enforcement", "require task", "task gate", "relax", "blocked", "policy"],
+  result: TaskPolicyResult,
+  handler: async (inv) => showPolicy2(inv.deps)
+});
+var taskPolicySetCommand = defineCommand({
+  path: ["task", "policy", "set"],
+  summary: "Require, or relax, the active-task rule for the project (owners and admins)",
+  description: "Sets the project's task requirement. Relaxing needs --reason and is recorded as a ledger event and shown in the context packet; it is never silent. Agent tokens cannot change it.",
+  args: [{ name: "enforcement", required: true, description: "required or relaxed" }],
+  flags: [{ name: "reason", type: "string", value: "TEXT", description: "Why the rule is relaxed (required for relaxed)" }],
+  examples: ["overlane task policy set required", 'overlane task policy set relaxed --reason "docs-only repository"'],
+  effect: "write",
+  ...common3,
+  keywords: ["relax", "turn off task requirement", "require tasks", "allow edits without task", "enforcement"],
+  result: TaskPolicySetResult,
+  handler: async (inv) => setPolicy(inv.deps, { enforcement: inv.positionals[0], reason: textFlag(inv, "reason"), dryRun: inv.dryRun })
+});
+var queueCommands = [taskNewCommand, taskNextCommand, taskQueueCommand, taskPrioritiseCommand, taskPolicyCommand, taskPolicySetCommand];
+
 // ../cli/src/task/results.ts
 init_zod();
 var TaskListResult = external_exports.object({ tasks: external_exports.array(TaskSummary) });
@@ -58267,34 +58569,35 @@ var TaskHandoffResult = withDryRun(
 );
 
 // ../cli/src/commands/task.ts
-var common3 = { needsAuth: true, needsNetwork: true };
+var common4 = { needsAuth: true, needsNetwork: true };
 var taskListCommand = defineCommand({
   path: ["task", "list"],
   summary: "List the project's tasks and their states",
   description: "Lists every task of the connected project with its state, pause reason, version, lease holder, checks and latest checkpoint.",
   examples: ["overlane task list"],
   effect: "read",
-  ...common3,
+  ...common4,
   keywords: ["tasks", "show all tasks", "see tasks", "backlog", "what tasks exist", "work items"],
   result: TaskListResult,
   handler: async (inv) => listTasks(inv.deps)
 });
 var taskStartCommand = defineCommand({
   path: ["task", "start"],
-  summary: "Create a task with a contract and claim it for this working copy",
-  description: "Creates a task (outcome, acceptance criteria, required checks, allowed paths) at the current commit and claims it, writing the lease to .harness/task.json. Fails with exit 5 if this working copy already holds a task.",
+  summary: "Claim an existing task, or create one with a contract and claim it",
+  description: "With a TASK_ID, claims that ready or paused task for this working copy (same checks as `task resume`). Without one, creates a task (outcome, acceptance criteria, required checks, allowed paths) at the current commit and claims it, writing the lease to .harness/task.json. Fails with exit 5 if this working copy already holds a task.",
+  args: [{ name: "task-id", required: false, description: "An existing task to claim; omit to create one from the flags" }],
   flags: [
-    { name: "outcome", type: "string", required: true, value: "TEXT", description: "What the task must achieve (up to 500 characters)" },
-    { name: "criterion", type: "string", multiple: true, required: true, value: "TEXT", description: "An acceptance criterion; repeat for more" },
+    { name: "outcome", type: "string", value: "TEXT", description: "What the task must achieve (up to 500 characters)" },
+    { name: "criterion", type: "string", multiple: true, value: "TEXT", description: "An acceptance criterion; repeat for more" },
     { name: "check", type: "string", multiple: true, value: "ID:LEVEL", description: "A required check and its minimum evidence level, for example unit_tests:L2; repeat for more" },
-    { name: "path", type: "string", multiple: true, required: true, value: "GLOB", description: "A file pattern the task may change; repeat for more" }
+    { name: "path", type: "string", multiple: true, value: "GLOB", description: "A file pattern the task may change; repeat for more" }
   ],
-  examples: ['overlane task start --outcome "Add CSV export" --criterion "export works" --check unit_tests:L2 --path "src/**"', 'overlane task start --outcome "Fix login" --criterion "login passes" --path "src/auth/**" --dry-run'],
+  examples: ["overlane task start task-7", 'overlane task start --outcome "Add CSV export" --criterion "export works" --check unit_tests:L2 --path "src/**"', 'overlane task start --outcome "Fix login" --criterion "login passes" --path "src/auth/**" --dry-run'],
   effect: "write",
-  ...common3,
+  ...common4,
   keywords: ["begin", "create task", "new task", "open", "claim new", "work item", "contract", "acceptance criteria", "start working"],
   result: TaskStartResult,
-  handler: async (inv) => startTask(inv.deps, { outcome: textFlag(inv, "outcome"), criteria: listFlag(inv, "criterion"), paths: listFlag(inv, "path"), checks: listFlag(inv, "check"), dryRun: inv.dryRun })
+  handler: async (inv) => inv.positionals[0] !== void 0 ? startExisting(inv.deps, inv.positionals[0], inv.dryRun) : startTask(inv.deps, { outcome: textFlag(inv, "outcome"), criteria: listFlag(inv, "criterion"), paths: listFlag(inv, "path"), checks: listFlag(inv, "check"), dryRun: inv.dryRun })
 });
 var taskStatusCommand = defineCommand({
   path: ["task", "status"],
@@ -58302,7 +58605,7 @@ var taskStatusCommand = defineCommand({
   description: "Shows the held task from the service: state, lease, acceptance criteria, checks, evidence count and the latest checkpoint. Says so when nothing is held or the lease was lost.",
   examples: ["overlane task status"],
   effect: "read",
-  ...common3,
+  ...common4,
   keywords: ["current task", "what am i working on", "lease", "active task", "progress", "held task"],
   result: TaskStatusResult,
   handler: async (inv) => taskStatus(inv.deps)
@@ -58318,7 +58621,7 @@ var taskCheckpointCommand = defineCommand({
   ],
   examples: ['overlane task checkpoint --summary "Parser done" --next "Write the tests"', 'overlane task checkpoint --summary "Out of budget" --next "Resume" --pause quota'],
   effect: "write",
-  ...common3,
+  ...common4,
   keywords: ["save", "progress", "pause", "stop work", "park", "quota", "limit reached", "remember place", "snapshot", "save state", "out of budget"],
   result: TaskCheckpointResult,
   handler: async (inv) => checkpointTask(inv.deps, { summary: textFlag(inv, "summary"), next: textFlag(inv, "next"), pause: textFlag(inv, "pause"), dryRun: inv.dryRun })
@@ -58330,7 +58633,7 @@ var taskResumeCommand = defineCommand({
   args: [{ name: "task-id", required: true, description: "The task to resume" }],
   examples: ["overlane task resume task-1"],
   effect: "write",
-  ...common3,
+  ...common4,
   keywords: ["continue", "pick up", "restart", "reclaim", "after pause", "take over", "carry on"],
   result: TaskResumeResult,
   handler: async (inv) => resumeTask(inv.deps, { taskId: inv.positionals[0], dryRun: inv.dryRun })
@@ -58341,7 +58644,7 @@ var taskSubmitCommand = defineCommand({
   description: "Asks for verification at HEAD. The task is verified only when evidence at or above each required check's level exists for that commit: L2 comes from CI on the pushed commit, L1 from `overlane task evidence`.",
   examples: ["overlane task submit", "overlane task submit --dry-run"],
   effect: "write",
-  ...common3,
+  ...common4,
   keywords: ["finish", "done", "complete", "verify", "ready for review", "request verification", "hand in", "turn in"],
   result: TaskSubmitResult,
   handler: async (inv) => submitTask(inv.deps, { dryRun: inv.dryRun })
@@ -58357,7 +58660,7 @@ var taskEvidenceCommand = defineCommand({
   ],
   examples: ["overlane task evidence --level L1 -- pnpm test"],
   effect: "write",
-  ...common3,
+  ...common4,
   keywords: ["tests", "prove", "record test result", "verification", "run checks", "L1", "attest", "run the tests and record"],
   result: TaskEvidenceResult,
   handler: async (inv) => recordEvidence(inv.deps, { level: textFlag(inv, "level"), task: textFlag(inv, "task"), words: inv.positionals, dryRun: inv.dryRun })
@@ -58373,7 +58676,7 @@ var taskHandoffCommand = defineCommand({
   ],
   examples: ["overlane task handoff --to codex", 'overlane task handoff --to claude --summary "API done" --next "Add tests"'],
   effect: "write",
-  ...common3,
+  ...common4,
   keywords: ["hand off", "transfer", "give to", "switch agent", "other agent", "codex", "claude", "pass the task", "delegate", "move work", "swap agents"],
   result: TaskHandoffResult,
   handler: async (inv) => handoffTask(inv.deps, { summary: textFlag(inv, "summary"), next: textFlag(inv, "next"), to: textFlag(inv, "to"), dryRun: inv.dryRun })
@@ -58393,6 +58696,7 @@ function coreCommands() {
     doctorCommand,
     disconnectCommand,
     ...taskCommands,
+    ...queueCommands,
     ...runCommands,
     ...releaseCommands,
     ...identityCommands
@@ -58614,35 +58918,35 @@ init_src2();
 
 // src/data-dir.ts
 import { homedir } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 function dataDir(env = process.env, home = homedir()) {
   const override = env["MVRX_DATA_DIR"];
   if (override !== void 0 && override !== "") return override;
-  const base2 = env["XDG_DATA_HOME"] ?? (process.platform === "win32" ? env["LOCALAPPDATA"] : void 0) ?? (process.platform === "darwin" ? join24(home, "Library", "Application Support") : join24(home, ".local", "share"));
-  return join24(base2, "mvrx-harness");
+  const base2 = env["XDG_DATA_HOME"] ?? (process.platform === "win32" ? env["LOCALAPPDATA"] : void 0) ?? (process.platform === "darwin" ? join25(home, "Library", "Application Support") : join25(home, ".local", "share"));
+  return join25(base2, "mvrx-harness");
 }
 function marketplaceRoot(env = process.env, home = homedir()) {
-  return join24(dataDir(env, home), "marketplace");
+  return join25(dataDir(env, home), "marketplace");
 }
 
 // src/plugin.ts
 import { readFileSync as readFileSync6 } from "node:fs";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 import { parseArgs as parseArgs3 } from "node:util";
 
 // src/marketplace.ts
 init_src();
 import { createHash as createHash7 } from "node:crypto";
-import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync7, readdirSync as readdirSync3, readFileSync as readFileSync5, renameSync as renameSync5, rmSync as rmSync4, statSync, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname7, join as join25, relative, sep } from "node:path";
+import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync8, readdirSync as readdirSync3, readFileSync as readFileSync5, renameSync as renameSync6, rmSync as rmSync4, statSync, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname8, join as join26, relative, sep } from "node:path";
 var CLIENT_DIRS = ["claude", "codex"];
 var EMBEDDED_MANIFEST = "release-manifest.json";
-var INSTALLED_MANIFEST = join25(".release", "manifest.json");
+var INSTALLED_MANIFEST = join26(".release", "manifest.json");
 var MarketplaceError = class extends Error {
 };
 function loadEmbedded(packageRoot2) {
-  const dir = join25(packageRoot2, "plugins");
-  const path = join25(dir, EMBEDDED_MANIFEST);
+  const dir = join26(packageRoot2, "plugins");
+  const path = join26(dir, EMBEDDED_MANIFEST);
   if (!existsSync5(path)) throw new MarketplaceError(`this package has no embedded plugin release (${path} is missing)`);
   const parsed = ReleaseManifest.safeParse(JSON.parse(readFileSync5(path, "utf8")));
   if (!parsed.success) throw new MarketplaceError(`the embedded release manifest is invalid: ${parsed.error.message}`);
@@ -58655,7 +58959,7 @@ function listFiles(root, dir = root) {
   if (!existsSync5(dir)) return [];
   const out2 = [];
   for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-    const full = join25(dir, entry.name);
+    const full = join26(dir, entry.name);
     if (entry.isDirectory()) out2.push(...listFiles(root, full));
     else out2.push(relative(root, full).split(sep).join("/"));
   }
@@ -58667,7 +58971,7 @@ async function verifyTree(treeRoot, manifest) {
   if (recomputed !== manifest.digest) problems.push(`manifest digest ${manifest.digest} does not match its file list (${recomputed})`);
   const listed = new Set(manifest.files.map((file2) => file2.path));
   for (const file2 of manifest.files) {
-    const path = join25(treeRoot, file2.path);
+    const path = join26(treeRoot, file2.path);
     if (!existsSync5(path)) {
       problems.push(`missing: ${file2.path}`);
       continue;
@@ -58675,7 +58979,7 @@ async function verifyTree(treeRoot, manifest) {
     if (sha2562(readFileSync5(path)) !== file2.digest) problems.push(`modified: ${file2.path}`);
   }
   for (const client of CLIENT_DIRS) {
-    for (const found of listFiles(join25(treeRoot, client))) {
+    for (const found of listFiles(join26(treeRoot, client))) {
       if (!listed.has(`${client}/${found}`)) problems.push(`unlisted: ${client}/${found}`);
     }
   }
@@ -58683,7 +58987,7 @@ async function verifyTree(treeRoot, manifest) {
 }
 function readInstalledManifest(target) {
   try {
-    const parsed = ReleaseManifest.safeParse(JSON.parse(readFileSync5(join25(target, INSTALLED_MANIFEST), "utf8")));
+    const parsed = ReleaseManifest.safeParse(JSON.parse(readFileSync5(join26(target, INSTALLED_MANIFEST), "utf8")));
     return parsed.success ? parsed.data : null;
   } catch {
     return null;
@@ -58708,23 +59012,23 @@ async function syncMarketplace(embedded, target) {
   const staging = `${target}.new-${process.pid}`;
   const previous = `${target}.old-${process.pid}`;
   rmSync4(staging, { recursive: true, force: true });
-  mkdirSync7(staging, { recursive: true });
+  mkdirSync8(staging, { recursive: true });
   try {
     for (const client of CLIENT_DIRS) {
-      if (existsSync5(join25(embedded.dir, client))) cpSync(join25(embedded.dir, client), join25(staging, client), { recursive: true });
+      if (existsSync5(join26(embedded.dir, client))) cpSync(join26(embedded.dir, client), join26(staging, client), { recursive: true });
     }
-    mkdirSync7(join25(staging, ".release"), { recursive: true });
-    writeFileSync6(join25(staging, INSTALLED_MANIFEST), `${JSON.stringify(embedded.manifest, null, 2)}
+    mkdirSync8(join26(staging, ".release"), { recursive: true });
+    writeFileSync7(join26(staging, INSTALLED_MANIFEST), `${JSON.stringify(embedded.manifest, null, 2)}
 `);
     const after = await verifyTree(staging, embedded.manifest);
     if (after.length > 0) throw new MarketplaceError(`the copied plugin files do not match the release manifest:
   ${after.join("\n  ")}`);
-    mkdirSync7(dirname7(target), { recursive: true });
-    if (existsSync5(target)) renameSync5(target, previous);
+    mkdirSync8(dirname8(target), { recursive: true });
+    if (existsSync5(target)) renameSync6(target, previous);
     try {
-      renameSync5(staging, target);
+      renameSync6(staging, target);
     } catch (error62) {
-      if (existsSync5(previous)) renameSync5(previous, target);
+      if (existsSync5(previous)) renameSync6(previous, target);
       throw error62;
     }
     rmSync4(previous, { recursive: true, force: true });
@@ -58746,7 +59050,7 @@ var PLUGIN_USAGE = `  overlane plugin install [--scope project|user] [--client c
 var PluginUsageError = class extends Error {
 };
 function readNames(treeRoot, client) {
-  const file2 = client === "claude" ? join26(treeRoot, "claude", ".claude-plugin", "marketplace.json") : join26(treeRoot, "codex", ".agents", "plugins", "marketplace.json");
+  const file2 = client === "claude" ? join27(treeRoot, "claude", ".claude-plugin", "marketplace.json") : join27(treeRoot, "codex", ".agents", "plugins", "marketplace.json");
   const parsed = JSON.parse(readFileSync6(file2, "utf8"));
   const record2 = parsed;
   const plugin = record2.plugins?.[0]?.name;
@@ -58793,7 +59097,7 @@ ${PLUGIN_USAGE}`);
       const key = `${names.plugin}@${names.marketplace}`;
       if (!await available(deps, client)) {
         if (explicit !== void 0) {
-          deps.stderr(`overlane: \`${client}\` was not found on PATH; the marketplace is at ${join26(root, client)}
+          deps.stderr(`overlane: \`${client}\` was not found on PATH; the marketplace is at ${join27(root, client)}
 `);
           failed = true;
         } else {
@@ -58805,7 +59109,7 @@ ${PLUGIN_USAGE}`);
       ranAny = true;
       deps.stdout(`${client}:
 `);
-      const dir = join26(root, client);
+      const dir = join27(root, client);
       const steps = client === "claude" ? [
         ["claude", ["plugin", "marketplace", "add", dir, "--scope", scope]],
         ["claude", ["plugin", "marketplace", "update", names.marketplace]],
@@ -58973,7 +59277,7 @@ var packageCommands = [indexBuildCommand, indexUploadCommand, shimCommand, plugi
 // src/deps.ts
 import { execFile as execFile3, spawn } from "node:child_process";
 import { homedir as homedir3 } from "node:os";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 import { createInterface } from "node:readline/promises";
 function exec(command, args2, options) {
   return new Promise((resolveResult) => {
@@ -59019,8 +59323,8 @@ async function confirm(question) {
   }
 }
 function configDir2(env) {
-  const base2 = env["XDG_CONFIG_HOME"] ?? (process.platform === "win32" ? env["APPDATA"] : void 0) ?? join29(homedir3(), ".config");
-  return join29(base2, "mvrx-harness");
+  const base2 = env["XDG_CONFIG_HOME"] ?? (process.platform === "win32" ? env["APPDATA"] : void 0) ?? join30(homedir3(), ".config");
+  return join30(base2, "mvrx-harness");
 }
 function createDeps2(env = process.env) {
   return {