@odla-ai/cli 0.42.2 → 0.43.0

package/dist/{cli-4FCRBWED.js → cli-OITEPXW4.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "./chunk-K6ATAKGR.js";
+} from "./chunk-WDWJ7HC7.js";
 import {
   exitCodeFor
 } from "./chunk-UKLSRQ5J.js";
@@ -9,4 +9,4 @@ export {
   exitCodeFor,
   runCli
 };
-//# sourceMappingURL=cli-4FCRBWED.js.map
+//# sourceMappingURL=cli-OITEPXW4.js.map

package/dist/index.cjs

@@ -10824,7 +10824,8 @@ Usage:
   odla-ai pm bug list [--app <id>] [--status <s>] [--severity <s>] [--goal <id>] [--assignee <id>] [--decision <id>] [--q <text>] [--limit <n>] [--offset <n>] [--json]
   odla-ai pm goal add --app <id> --title <t> [--status <s>] [--proof <text>] [--target <pct>] [--mutation-id <id>] [--json]
   odla-ai pm task add --app <id> --title <t> [--column <backlog|ready|doing|review|done>] [--goal <id>|--alignment-decision <id>] [--assignee <id>] [--description <text>|--body <text>] [--acceptance <text>] [--execution <human|agent|either>] [--due <epoch-ms>] [--mutation-id <id>] [--json]
-  odla-ai pm next --app <id> [--project <id>] [--json]
+  odla-ai pm next --app <id> [--project <id>] [--verbose] [--json]
+  odla-ai pm start --app <id> [<task-id>] [--goal <id>] [--verbose] [--mutation-id <id>] [--json]   [claims the top Ready task in one call]
   odla-ai pm watch --app <id> [--cursor <cursor>] [--entity goal|task|decision|bug] [--action created|updated|deleted|comment.created|comment.updated] [--state <state>] [--by <principalId>] [--self <principalId>] [--interval <s>] [--timeout <s>] [--json|--jsonl]
   odla-ai pm task ready <id> --expected-revision <n> [--goal <id>|--alignment-decision <id>] [--description <text>|--body <text>] [--acceptance <text>] [--execution <human|agent|either>] [--mutation-id <id>] [--json]
   odla-ai pm task claim <id> --expected-revision <n> [--mutation-id <id>] [--json]
@@ -10845,7 +10846,7 @@ Usage:
   odla-ai pm <goal|task|decision|bug> comments <id> [--json]
   odla-ai pm <goal|task|decision|bug> history <id> [--limit <n>] [--json]
   odla-ai pm <goal|task|decision|bug> rm <id>
-  odla-ai pm handoff --app <id> [--project <id>] [--json]
+  odla-ai pm handoff --app <id> [--project <id>] [--verbose] [--json]
   odla-ai discuss groups [--json]
   odla-ai discuss list [--app <id>] [--q <text>] [--state open|resolved|all] [--mentions] [--json]
   odla-ai discuss read <topic> [--limit <n> --offset <n>] [--json]
@@ -11010,6 +11011,16 @@ Commands:
                execution contract and a reviewed revision. Any caller with PM
                mutation access to that app/project may do it; claims coordinate
                execution but never own or lock the PM record.
+               To pick up work: "pm next" reads open goals, Ready candidates,
+               and work in progress; "pm start" claims the top Ready task in
+               one call, compare-and-swapped on the revision it just read, and
+               returns the task, its goal, and the acceptance criteria to work
+               against. Finish with "pm task done <id>", or hand it back with
+               "pm task release <id> --expected-revision <n>". "pm start" never
+               marks work Ready: that contract is reviewed separately so an
+               agent cannot authorize its own work.
+               Intake output is projected to the fields an executing caller
+               acts on; --verbose returns whole records with their audit trail.
   bug          Intent-first alias for PM bugs. "bug report" writes to
                odla PM; odla product defects do not belong in GitHub Issues.
   discuss      Group discussions (via @odla-ai/chat) for the apps you co-own:
@@ -11760,6 +11771,15 @@ var FIELD_MAP = {
   execution: { key: "executionMode" },
   "expected-revision": { key: "expectedRevision", num: true }
 };
+var PmRequestError = class extends Error {
+  constructor(status, message2) {
+    super(message2);
+    this.status = status;
+    this.name = "PmRequestError";
+  }
+  status;
+};
+var isRevisionConflict = (error) => error instanceof PmRequestError && error.status === 409;
 async function pmRequest(ctx, method, path, body) {
   const response2 = await ctx.doFetch(`${ctx.platformUrl}/registry/pm${path}`, {
     method,
@@ -11779,7 +11799,8 @@ async function pmRequest(ctx, method, path, body) {
       const message2 = error.message;
       if (typeof message2 === "string" && message2.length > 0) detail = message2;
     }
-    throw new Error(
+    throw new PmRequestError(
+      response2.status,
       `pm ${method} ${path} failed: ${detail ?? `registry returned ${response2.status}`} (${response2.status})`
     );
   }
@@ -11968,103 +11989,196 @@ async function pmTaskLifecycle(ctx, id2, action2, parsed) {
     ctx.out.log(`task: ${label} \u2192 ${state2}`);
   });
 }
-async function allRecords(ctx, entity, appId, projectId) {
+async function pmRemove(ctx, entity, id2) {
+  await pmRequest(ctx, "DELETE", `/${entity}/${encodeURIComponent(id2)}`);
+  ctx.out.log(`deleted ${entity} ${id2}`);
+}
+
+// src/pm-lean.ts
+var COMMON = ["id", "appId", "projectId", "title", "revision"];
+var PER_ENTITY = {
+  goal: ["status", "proof", "targetPct", "currentPct"],
+  task: [
+    "column",
+    "goalId",
+    "alignmentDecisionId",
+    "description",
+    "acceptanceCriteria",
+    "executionMode",
+    "assigneeId",
+    "claimedByPrincipalId",
+    "dueAt"
+  ],
+  decision: ["status", "body", "supersedesId"],
+  bug: ["status", "severity", "description", "goalId", "assigneeId", "decisionId"]
+};
+function leanRecord(entity, record11) {
+  const out = {};
+  for (const key of [...COMMON, ...PER_ENTITY[entity]]) {
+    const value2 = record11[key];
+    if (value2 !== void 0 && value2 !== null) out[key] = value2;
+  }
+  return out;
+}
+function leanRecords(entity, records, verbose) {
+  return verbose ? records : records.map((record11) => leanRecord(entity, record11));
+}
+
+// src/pm-intake.ts
+var READY_COLUMN = "todo";
+var UNMET_GOAL_STATUS = "open";
+var ACTIVE_TASK_COLUMNS = "backlog,todo,doing,review";
+var OPEN_BUG_STATUSES = "open,triaged";
+var wantsVerbose = (parsed) => parsed.options.verbose === true;
+async function listFiltered(ctx, entity, appId, projectId, filters) {
   const records = [];
   for (; ; ) {
-    const q = new URLSearchParams({
-      app: appId,
-      limit: "100",
-      offset: String(records.length)
-    });
+    const q = new URLSearchParams({ app: appId, limit: "100", offset: String(records.length) });
     if (projectId) q.set("project", projectId);
+    for (const [key, value2] of Object.entries(filters)) q.set(key, value2);
     const page2 = await pmRequest(ctx, "GET", `/${entity}?${q}`);
     records.push(...page2.records);
     if (records.length >= page2.total || page2.records.length === 0) return records;
   }
 }
-async function pmNext(ctx, parsed) {
+function requireApp(ctx, parsed, command) {
   const appId = stringOpt(parsed.options.app) ?? ctx.appId;
-  const projectId = stringOpt(parsed.options.project) ?? ctx.projectId;
-  if (!appId) throw new Error("pm next needs --app <appId>");
+  if (!appId) throw new Error(`pm ${command} needs --app <appId>`);
+  return { appId, projectId: stringOpt(parsed.options.project) ?? ctx.projectId };
+}
+async function pmNext(ctx, parsed) {
+  const { appId, projectId } = requireApp(ctx, parsed, "next");
+  const verbose = wantsVerbose(parsed);
   const [goals, tasks] = await Promise.all([
-    allRecords(ctx, "goal", appId, projectId),
-    allRecords(ctx, "task", appId, projectId)
+    listFiltered(ctx, "goal", appId, projectId, { status: UNMET_GOAL_STATUS }),
+    // One request for both live columns; the split below is over open work only.
+    listFiltered(ctx, "task", appId, projectId, { column: `${READY_COLUMN},doing` })
   ]);
+  const ready = tasks.filter((record11) => record11.column === READY_COLUMN);
+  const doing = tasks.filter((record11) => record11.column === "doing");
+  const guidance = !goals.length ? "discuss alignment with the user before creating or claiming project work" : !ready.length ? 'refine a linked Backlog task and mark it Ready with "pm task ready <id>"' : `claim the top Ready task in one call: odla-ai pm start --app ${appId}`;
   const result = {
     appId,
     projectId,
-    openGoals: goals.filter((record11) => record11.status === "open"),
-    doing: tasks.filter((record11) => record11.column === "doing"),
-    ready: tasks.filter((record11) => record11.column === "todo")
+    openGoals: leanRecords("goal", goals, verbose),
+    doing: leanRecords("task", doing, verbose),
+    ready: leanRecords("task", ready, verbose),
+    next: guidance
   };
   emit2(ctx, result, () => {
     ctx.out.log(`${appId}: goal-aligned work intake (read only)`);
-    for (const [label, records] of [
-      ["doing", result.doing],
-      ["ready", result.ready],
-      ["open goals", result.openGoals]
+    for (const [label, entity, records] of [
+      ["doing", "task", doing],
+      ["ready", "task", ready],
+      ["open goals", "goal", goals]
     ]) {
       ctx.out.log(`${label}:`);
       if (!records.length) ctx.out.log("- (none)");
-      else for (const record11 of records) printRecord(
-        ctx,
-        label === "open goals" ? "goal" : "task",
-        record11
-      );
-    }
-    if (!result.openGoals.length) {
-      ctx.out.log("next: discuss alignment with the user before creating or claiming project work");
-    } else if (!result.ready.length) {
-      ctx.out.log("next: refine a linked Backlog task and mark it Ready");
-    } else {
-      ctx.out.log("next: review a Ready task, then claim it with its revision");
+      else for (const record11 of records) printRecord(ctx, entity, record11);
     }
+    ctx.out.log(`next: ${guidance}`);
   });
 }
 async function pmHandoff(ctx, parsed) {
-  const appId = stringOpt(parsed.options.app) ?? ctx.appId;
-  const projectId = stringOpt(parsed.options.project) ?? ctx.projectId;
-  if (!appId) throw new Error("pm handoff needs --app <appId>");
+  const { appId, projectId } = requireApp(ctx, parsed, "handoff");
+  const verbose = wantsVerbose(parsed);
   const [goals, tasks, bugs] = await Promise.all([
-    allRecords(ctx, "goal", appId, projectId),
-    allRecords(ctx, "task", appId, projectId),
-    allRecords(ctx, "bug", appId, projectId)
+    listFiltered(ctx, "goal", appId, projectId, { status: UNMET_GOAL_STATUS }),
+    listFiltered(ctx, "task", appId, projectId, { column: ACTIVE_TASK_COLUMNS }),
+    listFiltered(ctx, "bug", appId, projectId, { status: OPEN_BUG_STATUSES })
   ]);
-  const handoff = {
+  const clean4 = !goals.length && !tasks.length && !bugs.length;
+  const result = {
     appId,
     projectId,
-    unmetGoals: goals.filter((record11) => record11.status !== "met"),
-    activeTasks: tasks.filter((record11) => record11.column !== "done"),
-    openBugs: bugs.filter((record11) => record11.status !== "fixed" && record11.status !== "wontfix")
-  };
-  const result = {
-    ...handoff,
-    clean: !handoff.unmetGoals.length && !handoff.activeTasks.length && !handoff.openBugs.length
+    unmetGoals: leanRecords("goal", goals, verbose),
+    activeTasks: leanRecords("task", tasks, verbose),
+    openBugs: leanRecords("bug", bugs, verbose),
+    clean: clean4
   };
   emit2(ctx, result, () => {
-    if (result.clean) {
+    if (clean4) {
       ctx.out.log(`${appId}: no unresolved PM work`);
       return;
     }
     ctx.out.log(`${appId}: authoritative PM handoff`);
-    for (const [label, records] of [
-      ["unmet goals", result.unmetGoals],
-      ["active tasks", result.activeTasks],
-      ["open bugs", result.openBugs]
+    for (const [label, entity, records] of [
+      ["unmet goals", "goal", goals],
+      ["active tasks", "task", tasks],
+      ["open bugs", "bug", bugs]
     ]) {
       ctx.out.log(`${label}:`);
       if (!records.length) ctx.out.log("- (none)");
-      else for (const record11 of records) printRecord(
-        ctx,
-        label === "unmet goals" ? "goal" : label === "active tasks" ? "task" : "bug",
-        record11
-      );
+      else for (const record11 of records) printRecord(ctx, entity, record11);
     }
   });
 }
-async function pmRemove(ctx, entity, id2) {
-  await pmRequest(ctx, "DELETE", `/${entity}/${encodeURIComponent(id2)}`);
-  ctx.out.log(`deleted ${entity} ${id2}`);
+
+// src/pm-start.ts
+var getTask = async (ctx, id2) => (await pmRequest(ctx, "GET", `/task/${encodeURIComponent(id2)}`)).record;
+async function claimAt(ctx, task, parsed) {
+  const res = await pmRequest(
+    ctx,
+    "POST",
+    `/task/${encodeURIComponent(task.id)}/claim`,
+    { expectedRevision: task.revision, mutationId: writeMutationId2(parsed) }
+  );
+  return res.record;
+}
+async function selectTask(ctx, parsed, appId, projectId) {
+  const named = parsed.positionals[2];
+  if (named) return getTask(ctx, named);
+  const goalId = stringOpt(parsed.options.goal);
+  const ready = await listFiltered(ctx, "task", appId, projectId, {
+    column: READY_COLUMN,
+    ...goalId ? { goalId } : {}
+  });
+  const candidate = ready[0];
+  if (!candidate) {
+    throw new Error(
+      `no Ready task to claim in ${appId}${goalId ? ` for goal ${goalId}` : ""}. Run "odla-ai pm next --app ${appId}" to see open goals and Backlog work, then "odla-ai pm task ready <id>" once a task has a complete contract.`
+    );
+  }
+  return candidate;
+}
+async function pmStart(ctx, parsed) {
+  const appId = stringOpt(parsed.options.app) ?? ctx.appId;
+  if (!appId) throw new Error("pm start needs --app <appId>");
+  const projectId = stringOpt(parsed.options.project) ?? ctx.projectId;
+  const verbose = wantsVerbose(parsed);
+  const selected = await selectTask(ctx, parsed, appId, projectId);
+  if (selected.column !== READY_COLUMN) {
+    throw new Error(
+      `task ${selected.id} is ${selected.column === "doing" ? "already claimed" : `in ${selected.column}`}, not Ready. Only Ready work can be started; run "odla-ai pm task ready ${selected.id} --expected-revision ${selected.revision}" once its goal, description, and acceptance criteria are complete.`
+    );
+  }
+  let claimed;
+  try {
+    claimed = await claimAt(ctx, selected, parsed);
+  } catch (error) {
+    if (!isRevisionConflict(error)) throw error;
+    const reloaded = await getTask(ctx, selected.id);
+    if (reloaded.column !== READY_COLUMN) {
+      throw new Error(
+        `task ${selected.id} was taken while starting it (now ${reloaded.column}). Run "odla-ai pm start --app ${appId}" again to take the next Ready task.`
+      );
+    }
+    claimed = await claimAt(ctx, reloaded, parsed);
+  }
+  const task = claimed ?? await getTask(ctx, selected.id);
+  const goalId = typeof task.goalId === "string" ? task.goalId : void 0;
+  const goal = goalId ? await pmRequest(ctx, "GET", `/goal/${encodeURIComponent(goalId)}`).then((res) => res.record).catch(() => null) : null;
+  const result = {
+    claimed: verbose ? task : leanRecord("task", task),
+    goal: goal ? verbose ? goal : leanRecord("goal", goal) : null,
+    next: 'work the acceptance criteria, then "odla-ai pm task done <id>" (or "odla-ai pm task release <id> --expected-revision <n>" to hand it back)'
+  };
+  emit2(ctx, result, () => {
+    ctx.out.log(`claimed: ${studioRecordLink(ctx, "task", task)}`);
+    if (goal) ctx.out.log(`goal: ${studioRecordLink(ctx, "goal", goal)}`);
+    if (typeof task.acceptanceCriteria === "string") ctx.out.log(`acceptance: ${task.acceptanceCriteria}`);
+    ctx.out.log(`next: ${result.next}`);
+  });
 }
 
 // src/pm-links.ts
@@ -12538,9 +12652,13 @@ async function pmCommand(parsed, deps = {}) {
     throw new Error(`unknown pm project action "${action3}". Try list|add|use.`);
   }
   if (word === "next") {
-    assertArgs(parsed, [...COMMON_OPTIONS, "app", "project"], 2);
+    assertArgs(parsed, [...COMMON_OPTIONS, "app", "project", "verbose"], 2);
     return pmNext(await buildContext2(parsed, deps), parsed);
   }
+  if (word === "start") {
+    assertArgs(parsed, [...COMMON_OPTIONS, "app", "project", "goal", "verbose", "mutation-id"], 3);
+    return pmStart(await buildContext2(parsed, deps), parsed);
+  }
   if (word === "watch") {
     assertArgs(parsed, [
       ...COMMON_OPTIONS,
@@ -12558,11 +12676,11 @@ async function pmCommand(parsed, deps = {}) {
     return pmWatch(await buildContext2(parsed, deps), parsed).then(() => void 0);
   }
   if (word === "handoff") {
-    assertArgs(parsed, [...COMMON_OPTIONS, "app", "project"], 2);
+    assertArgs(parsed, [...COMMON_OPTIONS, "app", "project", "verbose"], 2);
     return pmHandoff(await buildContext2(parsed, deps), parsed);
   }
   const entity = ALIASES[word];
-  if (!entity) throw new Error(`unknown pm entity "${word}". Try "odla-ai pm bug list" (goal|task|decision|bug).`);
+  if (!entity) throw new Error(`unknown pm entity "${word}". Try "odla-ai pm start" to claim Ready work, or "odla-ai pm bug list" (goal|task|decision|bug).`);
   const requestedAction = parsed.positionals[2] ?? "list";
   const action2 = canonicalAction(requestedAction);
   if (!action2) throw new Error(`unknown pm action "${requestedAction}". Try list|add|get|set|done|link|ref|comment|comments|history|rm.`);