@poetic-ai/poetic 1.42.0

package/dist/chunk-F23DIWNN.js

@@ -0,0 +1,1024 @@
+import {
+  queryCanonicalPlanningProjection
+} from "./chunk-Z6PC7QX6.js";
+import {
+  getAllTasks
+} from "./chunk-5LTN43AS.js";
+import {
+  calculateCapacity,
+  computeSprintTerminalReadiness,
+  getCurrentSprint,
+  listSprints,
+  listTasksInSprint
+} from "./chunk-4YX7J6QL.js";
+import {
+  getPlanningRoot
+} from "./chunk-OPYFYTWQ.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketPathByKind,
+  listEnabledBuckets
+} from "./chunk-HOYBYAOA.js";
+import {
+  resolveDefaultBranch
+} from "./chunk-XQD2B6BB.js";
+import {
+  GitExecError,
+  execGit
+} from "./chunk-KNDYMVWN.js";
+import {
+  PLANNING_GIT_NETWORK_TIMEOUT_MS
+} from "./chunk-LAMKBTXX.js";
+import {
+  isSafeGitRemoteAndRef
+} from "./chunk-QOCOVLUH.js";
+import {
+  toRepoRelativePath
+} from "./chunk-XZE4XARH.js";
+import {
+  POETIC_DEFER_SYNC,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/planning/git-sync.ts
+import chalk from "chalk";
+
+// src/planning/git-exec.ts
+var NETWORK_GIT_SUBCOMMANDS = /* @__PURE__ */ new Set(["fetch", "ls-remote", "pull", "push"]);
+async function runPlanningGit(args, options) {
+  const networkTimeoutMs = NETWORK_GIT_SUBCOMMANDS.has(args[0] ?? "") ? PLANNING_GIT_NETWORK_TIMEOUT_MS : void 0;
+  try {
+    const result = await execGit(args, {
+      cwd: options.cwd,
+      ...options.env ? { env: options.env } : {},
+      ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : networkTimeoutMs !== void 0 ? { timeoutMs: networkTimeoutMs } : {}
+    });
+    if (options.reject !== false && result.exitCode !== 0) {
+      throw new Error(
+        `git ${args.join(" ")} failed with exit ${result.exitCode}: ${result.stderr}`
+      );
+    }
+    return result;
+  } catch (error) {
+    if (options.reject === false && error instanceof GitExecError) {
+      return {
+        exitCode: void 0,
+        stdout: "",
+        stderr: error.message,
+        ...error.timedOut ? { timedOut: true } : {}
+      };
+    }
+    throw error;
+  }
+}
+
+// src/planning/remote-sync-verify.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var DEFAULT_VERIFY_DELAYS_MS = [0, 2e3, 4e3];
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function resolveRemoteBranchSha(projectRoot, remote, remoteBranch) {
+  if (!isSafeGitRemoteAndRef(remote, remoteBranch)) {
+    return "";
+  }
+  const lsRemote = await runPlanningGit(["ls-remote", "--heads", "--", remote, remoteBranch], {
+    cwd: projectRoot,
+    reject: false
+  });
+  if (lsRemote.exitCode !== 0) {
+    return "";
+  }
+  return lsRemote.stdout.trim().split(/\s+/)[0] ?? "";
+}
+async function remoteContainsCommit(projectRoot, remote, remoteBranch, commitSha) {
+  const remoteSha = await resolveRemoteBranchSha(projectRoot, remote, remoteBranch);
+  if (!remoteSha) {
+    return false;
+  }
+  if (remoteSha === commitSha) {
+    return true;
+  }
+  const ancestorCheck = await runPlanningGit(
+    ["merge-base", "--is-ancestor", commitSha, remoteSha],
+    {
+      cwd: projectRoot,
+      reject: false
+    }
+  );
+  return ancestorCheck.exitCode === 0;
+}
+async function remoteContainsPaths(projectRoot, remote, remoteBranch, relativePaths) {
+  const remoteRef = `${remote}/${remoteBranch}`;
+  for (const relativePath of relativePaths) {
+    const showResult = await runPlanningGit(["show", `${remoteRef}:${relativePath}`], {
+      cwd: projectRoot,
+      reject: false
+    });
+    if (showResult.exitCode !== 0) {
+      return { ok: false, missingPath: relativePath };
+    }
+  }
+  return { ok: true };
+}
+async function verifyRemoteSyncPush(options) {
+  const {
+    projectRoot,
+    remote,
+    remoteBranch,
+    relativePaths,
+    expectedCommitSha,
+    maxAttempts = 3,
+    verifyDelaysMs = DEFAULT_VERIFY_DELAYS_MS
+  } = options;
+  if (!expectedCommitSha) {
+    return { ok: false, reason: "missing expected commit SHA for remote verification" };
+  }
+  if (!isSafeGitRemoteAndRef(remote, remoteBranch)) {
+    return {
+      ok: false,
+      reason: "upstream remote or branch name is not a safe git identifier"
+    };
+  }
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const delayMs = verifyDelaysMs[attempt] ?? verifyDelaysMs.at(-1) ?? 0;
+    if (delayMs > 0) {
+      await sleep(delayMs);
+    }
+    const fetchResult = await runPlanningGit(["fetch", "--", remote, remoteBranch], {
+      cwd: projectRoot,
+      reject: false
+    });
+    if (fetchResult.exitCode !== 0) {
+      if (attempt === maxAttempts - 1) {
+        const fetchDetail = fetchResult.stderr?.split("\n").find((line) => line.trim().length > 0) ?? fetchResult.stdout?.split("\n").find((line) => line.trim().length > 0) ?? "fetch failed";
+        return {
+          ok: false,
+          reason: `remote verification fetch failed after ${maxAttempts} attempts: ${fetchDetail}`
+        };
+      }
+      continue;
+    }
+    const remoteSha = await resolveRemoteBranchSha(projectRoot, remote, remoteBranch);
+    if (!remoteSha) {
+      if (attempt === maxAttempts - 1) {
+        return {
+          ok: false,
+          reason: `remote branch ${remote}/${remoteBranch} not found after push`
+        };
+      }
+      continue;
+    }
+    const commitVisible = await remoteContainsCommit(
+      projectRoot,
+      remote,
+      remoteBranch,
+      expectedCommitSha
+    );
+    if (!commitVisible) {
+      if (attempt === maxAttempts - 1) {
+        return {
+          ok: false,
+          reason: `remote ${remote}/${remoteBranch} at ${remoteSha} does not contain pushed commit ${expectedCommitSha}`
+        };
+      }
+      continue;
+    }
+    if (relativePaths.length > 0) {
+      const pathCheck = await remoteContainsPaths(projectRoot, remote, remoteBranch, relativePaths);
+      if (!pathCheck.ok) {
+        if (attempt === maxAttempts - 1) {
+          return {
+            ok: false,
+            reason: `remote ${remote}/${remoteBranch} is missing synced path ${pathCheck.missingPath}`
+          };
+        }
+        continue;
+      }
+    }
+    return { ok: true, remoteSha };
+  }
+  return { ok: false, reason: "remote verification failed after retries" };
+}
+function isRefspecPushTopology(localBranch, remoteBranch) {
+  return localBranch.length > 0 && remoteBranch.length > 0 && localBranch !== remoteBranch;
+}
+async function filterExistingRelativePaths(projectRoot, relativePaths) {
+  const existingPaths = [];
+  for (const relativePath of relativePaths) {
+    try {
+      await fs.access(path.join(projectRoot, relativePath));
+      existingPaths.push(relativePath);
+    } catch {
+    }
+  }
+  return existingPaths;
+}
+
+// src/planning/git-sync.ts
+var GENERATED_PLANNING_INDEX_CACHE_REL_PATH = ".poetic/planning/indexes";
+function isDeferSyncEnabled() {
+  return readEnv(POETIC_DEFER_SYNC).value ?? false;
+}
+function isMissingRemoteError(output) {
+  return /does not appear to be a git repository|couldn't find remote ref|repository .* not found|no such remote/i.test(
+    output
+  );
+}
+var ManagedSyncBranchError = class extends Error {
+  branch;
+  defaultBranch;
+  constructor(message, details) {
+    super(message);
+    this.name = "ManagedSyncBranchError";
+    this.branch = details?.branch ?? "";
+    this.defaultBranch = details?.defaultBranch ?? "";
+  }
+};
+function formatManagedSyncBranchError(error) {
+  if (error.branch.length > 0 && error.defaultBranch.length > 0) {
+    return `Managed auto-sync refuses branch ${error.branch}; switch to ${error.defaultBranch} or use a dedicated backlog sync branch`;
+  }
+  return error.message;
+}
+function isManagedSyncBranchError(error) {
+  return error instanceof ManagedSyncBranchError || error instanceof Error && error.name === "ManagedSyncBranchError";
+}
+async function assertManagedSyncBranch(projectRoot, branch) {
+  const defaultBranch = await resolveDefaultBranch(projectRoot);
+  if (branch === defaultBranch || branch.startsWith("chore/backlog-sync-")) {
+    return;
+  }
+  throw new ManagedSyncBranchError(
+    `Managed auto-sync refuses branch ${branch}; switch to ${defaultBranch} or use a dedicated backlog sync branch`,
+    { branch, defaultBranch }
+  );
+}
+function firstGitLine(output) {
+  return output?.split("\n").find((line) => line.trim().length > 0)?.trim() ?? "unknown";
+}
+function splitNulTerminatedPaths(stdout) {
+  return stdout.split("\0").filter((entry) => entry.length > 0);
+}
+function isWithinRelPath(candidate, root) {
+  return candidate === root || candidate.startsWith(`${root}/`);
+}
+async function stageIgnoredTrackedPathsForSync(projectRoot, relRootPath) {
+  const trackedResult = await runPlanningGit(["ls-files", "-z", "--", relRootPath], {
+    cwd: projectRoot,
+    reject: false
+  });
+  if (trackedResult.exitCode !== 0 || trackedResult.stdout.length === 0) {
+    return [];
+  }
+  const trackedPaths = splitNulTerminatedPaths(trackedResult.stdout).filter(
+    (trackedPath) => isWithinRelPath(trackedPath, relRootPath)
+  );
+  if (trackedPaths.length === 0) {
+    return [];
+  }
+  const ignoredTrackedPaths = [];
+  for (const trackedPath of trackedPaths) {
+    const ignoreResult = await runPlanningGit(
+      ["check-ignore", "--no-index", "-q", "--", trackedPath],
+      {
+        cwd: projectRoot,
+        reject: false
+      }
+    );
+    if (ignoreResult.exitCode === 0) {
+      ignoredTrackedPaths.push(trackedPath);
+    }
+  }
+  if (ignoredTrackedPaths.length === 0) {
+    return [];
+  }
+  const rmResult = await runPlanningGit(
+    ["rm", "--cached", "--ignore-unmatch", "--", ...ignoredTrackedPaths],
+    {
+      cwd: projectRoot,
+      reject: false
+    }
+  );
+  if (rmResult.exitCode !== 0) {
+    return [];
+  }
+  return ignoredTrackedPaths;
+}
+async function stageGeneratedPlanningIndexCacheUntracking(projectRoot) {
+  return stageIgnoredTrackedPathsForSync(projectRoot, GENERATED_PLANNING_INDEX_CACHE_REL_PATH);
+}
+async function hasStagedChanges(projectRoot) {
+  const result = await runPlanningGit(["diff", "--cached", "--quiet"], {
+    cwd: projectRoot,
+    reject: false
+  });
+  return result.exitCode !== 0;
+}
+async function resolvePathsThisSyncWillStage(projectRoot, managedPaths, hadPreexistingStagedChanges) {
+  if (managedPaths.length === 0) {
+    return [];
+  }
+  if (!hadPreexistingStagedChanges) {
+    return [...managedPaths];
+  }
+  const alreadyStaged = new Set(await listStagedRelativePaths(projectRoot, managedPaths));
+  return managedPaths.filter((managedPath) => !alreadyStaged.has(managedPath));
+}
+async function unstageThisSyncPaths(projectRoot, paths) {
+  if (paths.length === 0) {
+    return;
+  }
+  await runPlanningGit(["reset", "--", ...paths], {
+    cwd: projectRoot,
+    reject: false
+  });
+}
+async function snapshotStagedIndexEntries(projectRoot, paths) {
+  if (paths.length === 0) {
+    return [];
+  }
+  const result = await runPlanningGit(["ls-files", "-s", "-z", "--", ...paths], {
+    cwd: projectRoot,
+    reject: false
+  });
+  if (result.exitCode !== 0 || !result.stdout) {
+    return [];
+  }
+  const entries = [];
+  for (const record of result.stdout.split("\0")) {
+    if (!record) continue;
+    const match = record.match(/^(\d{6}) ([0-9a-f]{40,64}) \d+\t(.+)$/);
+    if (!match?.[1] || !match[2] || !match[3]) continue;
+    entries.push({ mode: match[1], sha: match[2], path: match[3] });
+  }
+  return entries;
+}
+async function restoreStagedIndexEntries(projectRoot, entries) {
+  for (const entry of entries) {
+    await runPlanningGit(["update-index", "--cacheinfo", entry.mode, entry.sha, entry.path], {
+      cwd: projectRoot,
+      reject: false
+    });
+  }
+}
+async function captureManagedSyncStaging(projectRoot, managedPaths, hadPreexistingStagedChanges) {
+  const pathsThisSyncWillStage = await resolvePathsThisSyncWillStage(
+    projectRoot,
+    managedPaths,
+    hadPreexistingStagedChanges
+  );
+  return {
+    pathsThisSyncWillStage,
+    overlappingStagedSnapshots: await snapshotStagedIndexEntries(
+      projectRoot,
+      managedPaths.filter((managedPath) => !pathsThisSyncWillStage.includes(managedPath))
+    )
+  };
+}
+async function abandonManagedSyncStaging(projectRoot, state) {
+  await unstageThisSyncPaths(projectRoot, state.pathsStagedByThisSync);
+  await restoreStagedIndexEntries(projectRoot, state.overlappingStagedSnapshots);
+}
+async function stageManagedSyncPaths(projectRoot, relativePaths, hadPreexistingStagedChanges) {
+  const captured = await captureManagedSyncStaging(
+    projectRoot,
+    relativePaths,
+    hadPreexistingStagedChanges
+  );
+  if (relativePaths.length > 0) {
+    await runPlanningGit(["add", ...relativePaths], { cwd: projectRoot });
+  }
+  const generatedCacheUntrackedPaths = hadPreexistingStagedChanges ? [] : await stageGeneratedPlanningIndexCacheUntracking(projectRoot);
+  return {
+    stagingState: {
+      overlappingStagedSnapshots: captured.overlappingStagedSnapshots,
+      pathsStagedByThisSync: [...captured.pathsThisSyncWillStage, ...generatedCacheUntrackedPaths]
+    },
+    generatedCacheUntrackedPaths
+  };
+}
+async function listStagedRelativePaths(projectRoot, pathspecs) {
+  if (pathspecs.length === 0) {
+    return [];
+  }
+  const result = await runPlanningGit(
+    ["diff", "--cached", "--name-only", "-z", "--", ...pathspecs],
+    { cwd: projectRoot, reject: false }
+  );
+  return splitNulTerminatedPaths(result.stdout);
+}
+async function verifyManagedSyncPushBoundary(projectRoot, remote, remoteBranch, preSyncHeadSha, remoteBranchExists) {
+  if (!preSyncHeadSha) {
+    return {
+      ok: false,
+      reason: "could not resolve the pre-sync commit",
+      kind: "unresolved-base"
+    };
+  }
+  if (!isSafeGitRemoteAndRef(remote, remoteBranchExists ? remoteBranch : "HEAD")) {
+    return {
+      ok: false,
+      reason: "upstream remote or branch name is not a safe git identifier",
+      kind: "unresolved-base"
+    };
+  }
+  const fetchResult = await runPlanningGit(
+    remoteBranchExists ? ["fetch", "--", remote, remoteBranch] : ["fetch", "--", remote],
+    {
+      cwd: projectRoot,
+      reject: false
+    }
+  );
+  if (fetchResult.exitCode !== 0) {
+    return {
+      ok: false,
+      reason: `fetch failed: ${firstGitLine(fetchResult.stderr ?? fetchResult.stdout)}`,
+      kind: "fetch-failed"
+    };
+  }
+  const ancestryResult = remoteBranchExists ? await runPlanningGit(["merge-base", "--is-ancestor", preSyncHeadSha, "FETCH_HEAD"], {
+    cwd: projectRoot,
+    reject: false
+  }) : await runPlanningGit(
+    [
+      "for-each-ref",
+      "--format=%(refname)",
+      "--contains",
+      preSyncHeadSha,
+      `refs/remotes/${remote}/`
+    ],
+    { cwd: projectRoot, reject: false }
+  );
+  const baseIsPublished = ancestryResult.exitCode === 0 && (remoteBranchExists || ancestryResult.stdout.trim().length > 0);
+  if (!baseIsPublished) {
+    return {
+      ok: false,
+      reason: "the local branch already contained commits not present on the remote before managed sync",
+      kind: "unpublished-base"
+    };
+  }
+  return { ok: true };
+}
+async function resolveManagedSyncPushCandidate(projectRoot, expectedParentSha, allowedPaths) {
+  const headResult = await runPlanningGit(["rev-parse", "HEAD"], {
+    cwd: projectRoot,
+    reject: false
+  });
+  const candidateSha = headResult.exitCode === 0 ? headResult.stdout.trim() : "";
+  if (!candidateSha || !expectedParentSha) {
+    return { ok: false, reason: "could not resolve the managed sync candidate or its parent" };
+  }
+  const parentResult = await runPlanningGit(["rev-parse", `${candidateSha}^`], {
+    cwd: projectRoot,
+    reject: false
+  });
+  if (parentResult.exitCode !== 0 || parentResult.stdout.trim() !== expectedParentSha) {
+    return {
+      ok: false,
+      reason: "the final candidate was not exactly one managed sync commit above the remote base"
+    };
+  }
+  const changedPathsResult = await runPlanningGit(
+    ["diff-tree", "--no-commit-id", "--name-only", "-r", "-z", candidateSha],
+    { cwd: projectRoot, reject: false }
+  );
+  const changedPaths = splitNulTerminatedPaths(changedPathsResult.stdout);
+  const allowedPathSet = new Set(allowedPaths);
+  if (changedPathsResult.exitCode !== 0 || changedPaths.length === 0 || changedPaths.some((changedPath) => !allowedPathSet.has(changedPath))) {
+    return {
+      ok: false,
+      reason: "the final candidate changed paths outside the managed sync scope"
+    };
+  }
+  return { ok: true, sha: candidateSha };
+}
+async function syncPlanningFiles(projectRoot, filePaths, commitMessage, options = {}) {
+  const warnOrThrow = (message) => {
+    if (options.strict) {
+      throw new Error(message);
+    }
+    if (!options.silent) {
+      console.log(chalk.yellow(`  ${message}`));
+    }
+  };
+  const warnOrThrowRemoteSync = (message) => {
+    if (options.strict && !options.allowPushFailure) {
+      throw new Error(message);
+    }
+    if (!options.silent) {
+      console.log(chalk.yellow(`  ${message}`));
+    }
+  };
+  const stagingState = {
+    pathsStagedByThisSync: [],
+    overlappingStagedSnapshots: []
+  };
+  try {
+    const relativePaths = [
+      ...new Set(filePaths.map((fp) => toRepoRelativePath(projectRoot, fp)))
+    ].filter((fp) => fp.length > 0);
+    if (relativePaths.length === 0) {
+      if (options.strict && options.requireStagedChanges) {
+        throw new Error("Sync made no staged changes: no managed paths were provided");
+      }
+      return;
+    }
+    const syncablePaths = [];
+    for (const relativePath of relativePaths) {
+      const ignoreResult = await runPlanningGit(["check-ignore", "-q", "--", relativePath], {
+        cwd: projectRoot,
+        reject: false
+      });
+      if (ignoreResult.exitCode !== 0) {
+        syncablePaths.push(relativePath);
+      }
+    }
+    const hadPreexistingStagedChanges = await hasStagedChanges(projectRoot);
+    const capturedStaging = await captureManagedSyncStaging(
+      projectRoot,
+      syncablePaths,
+      hadPreexistingStagedChanges
+    );
+    const pathsThisSyncWillStage = capturedStaging.pathsThisSyncWillStage;
+    stagingState.overlappingStagedSnapshots = capturedStaging.overlappingStagedSnapshots;
+    const generatedCacheUntrackedPaths = hadPreexistingStagedChanges ? [] : await stageGeneratedPlanningIndexCacheUntracking(projectRoot);
+    const canCommitAllStaged = generatedCacheUntrackedPaths.length > 0;
+    const commitPaths = [...syncablePaths, ...generatedCacheUntrackedPaths];
+    const commitManagedPaths = () => runPlanningGit(
+      canCommitAllStaged ? ["commit", "-m", commitMessage] : ["commit", "-m", commitMessage, "--", ...commitPaths],
+      { cwd: projectRoot, reject: false }
+    );
+    if (commitPaths.length === 0) {
+      if (options.strict && options.requireStagedChanges) {
+        throw new Error(
+          `Sync made no staged changes for ignored paths: ${relativePaths.join(", ")}`
+        );
+      }
+      return;
+    }
+    if (syncablePaths.length > 0) {
+      await runPlanningGit(["add", ...syncablePaths], { cwd: projectRoot });
+    }
+    stagingState.pathsStagedByThisSync = [
+      ...pathsThisSyncWillStage,
+      ...generatedCacheUntrackedPaths
+    ];
+    const diffResult = await runPlanningGit(
+      canCommitAllStaged ? ["diff", "--cached", "--quiet"] : ["diff", "--cached", "--quiet", "--", ...commitPaths],
+      {
+        cwd: projectRoot,
+        reject: false
+      }
+    );
+    if (diffResult.exitCode === 0) {
+      if (options.strict && options.requireStagedChanges) {
+        throw new Error(`Sync made no staged changes for: ${commitPaths.join(", ")}`);
+      }
+      return;
+    }
+    const branchResult = await runPlanningGit(["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: projectRoot,
+      reject: false
+    });
+    const branch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : "";
+    if (!branch || branch === "HEAD") {
+      const detachedCommit = await commitManagedPaths();
+      if (detachedCommit.exitCode === 0) {
+        warnOrThrowRemoteSync("Committed locally (detached HEAD - skipped push)");
+      } else {
+        warnOrThrow(
+          `Commit failed (detached HEAD): ${detachedCommit.stderr?.split("\n")[0] ?? detachedCommit.stdout?.split("\n")[0] ?? "unknown"}`
+        );
+      }
+      return;
+    }
+    await assertManagedSyncBranch(projectRoot, branch);
+    const upstreamResult = await runPlanningGit(
+      ["rev-parse", "--abbrev-ref", `${branch}@{upstream}`],
+      { cwd: projectRoot, reject: false }
+    );
+    let remote = "origin";
+    let remoteBranch = branch;
+    const hasUpstream = upstreamResult.exitCode === 0;
+    if (hasUpstream) {
+      const upstream = upstreamResult.stdout.trim();
+      const slashIdx = upstream.indexOf("/");
+      if (slashIdx > 0) {
+        remote = upstream.slice(0, slashIdx);
+        remoteBranch = upstream.slice(slashIdx + 1);
+      }
+    }
+    if (!isSafeGitRemoteAndRef(remote, remoteBranch)) {
+      const unsafeCommit = await commitManagedPaths();
+      if (unsafeCommit.exitCode !== 0) {
+        warnOrThrow(`Commit failed: ${unsafeCommit.stderr?.split("\n")[0] ?? "unknown"}`);
+        return;
+      }
+      warnOrThrowRemoteSync(
+        "Committed locally but upstream remote or branch name is not a safe git identifier - push skipped"
+      );
+      return;
+    }
+    const preSyncHeadResult = await runPlanningGit(["rev-parse", "HEAD"], {
+      cwd: projectRoot,
+      reject: false
+    });
+    const preSyncHeadSha = preSyncHeadResult.exitCode === 0 ? preSyncHeadResult.stdout.trim() : "";
+    const remoteBranchResult = await runPlanningGit(
+      ["ls-remote", "--heads", "--", remote, remoteBranch],
+      {
+        cwd: projectRoot,
+        reject: false
+      }
+    );
+    const remoteBranchExists = remoteBranchResult.stdout.trim().length > 0;
+    if (remoteBranchResult.exitCode !== 0 && isMissingRemoteError(`${remoteBranchResult.stderr ?? ""}
+${remoteBranchResult.stdout ?? ""}`)) {
+      const offlineCommit = await commitManagedPaths();
+      if (offlineCommit.exitCode !== 0) {
+        warnOrThrow(`Commit failed: ${offlineCommit.stderr?.split("\n")[0] ?? "unknown"}`);
+        return;
+      }
+      warnOrThrowRemoteSync("Committed locally; no remote repository configured - push skipped");
+      return;
+    }
+    const pushBoundary = await verifyManagedSyncPushBoundary(
+      projectRoot,
+      remote,
+      remoteBranch,
+      preSyncHeadSha,
+      remoteBranchExists
+    );
+    if (!pushBoundary.ok && pushBoundary.kind === "unpublished-base") {
+      warnOrThrowRemoteSync(
+        `Not committed: ${pushBoundary.reason} - managed changes left staged, push skipped`
+      );
+      return;
+    }
+    const commitResult = await commitManagedPaths();
+    if (commitResult.exitCode !== 0) {
+      warnOrThrow(`Commit failed: ${commitResult.stderr?.split("\n")[0] ?? "unknown"}`);
+      return;
+    }
+    if (!pushBoundary.ok) {
+      warnOrThrowRemoteSync(`Committed locally but ${pushBoundary.reason} - push skipped`);
+      return;
+    }
+    const refspecTopology = isRefspecPushTopology(branch, remoteBranch);
+    const maxSyncAttempts = refspecTopology ? 1 : 3;
+    for (let attempt = 1; attempt <= maxSyncAttempts; attempt++) {
+      let expectedParentSha = preSyncHeadSha;
+      if (remoteBranchExists && !refspecTopology) {
+        const remoteHeadResult = await runPlanningGit(["rev-parse", "FETCH_HEAD"], {
+          cwd: projectRoot,
+          reject: false
+        });
+        expectedParentSha = remoteHeadResult.exitCode === 0 ? remoteHeadResult.stdout.trim() : "";
+        const rebaseResult = await runPlanningGit(["rebase", "FETCH_HEAD"], {
+          cwd: projectRoot,
+          reject: false
+        });
+        if (rebaseResult.exitCode !== 0) {
+          const rebaseStderr = rebaseResult.stderr ?? "";
+          const rebaseStdout = rebaseResult.stdout ?? "";
+          const rebaseOutputCombined = `${rebaseStderr}
+${rebaseStdout}`.toLowerCase();
+          const isConflict = rebaseOutputCombined.includes("conflict") || rebaseOutputCombined.includes("could not apply");
+          await runPlanningGit(["rebase", "--abort"], { cwd: projectRoot, reject: false });
+          const reason = isConflict ? "rebase conflicted (aborted rebase)" : `rebase failed: ${firstGitLine(rebaseStderr || rebaseStdout)}`;
+          warnOrThrowRemoteSync(`Committed locally but ${reason} - push skipped`);
+          return;
+        }
+      }
+      const candidate = await resolveManagedSyncPushCandidate(
+        projectRoot,
+        expectedParentSha,
+        commitPaths
+      );
+      if (!candidate.ok) {
+        warnOrThrowRemoteSync(`Committed locally but ${candidate.reason} - push skipped`);
+        return;
+      }
+      const shouldSetUpstream = !hasUpstream || !remoteBranchExists;
+      const pushArgs = shouldSetUpstream ? ["push", "-u", "--", remote, `${candidate.sha}:refs/heads/${remoteBranch}`] : ["push", "--", remote, `${candidate.sha}:${remoteBranch}`];
+      const pushResult = await runPlanningGit(pushArgs, {
+        cwd: projectRoot,
+        reject: false
+      });
+      if (pushResult.exitCode === 0) {
+        const verifyResult = await verifyRemoteSyncPush({
+          projectRoot,
+          remote,
+          remoteBranch,
+          relativePaths: await filterExistingRelativePaths(projectRoot, syncablePaths),
+          expectedCommitSha: candidate.sha
+        });
+        if (verifyResult.ok) {
+          if (!options.silent) {
+            console.log(chalk.gray("  Synced to remote"));
+          }
+          return;
+        }
+        warnOrThrowRemoteSync(
+          `Committed locally but remote verification failed: ${verifyResult.reason} - treat push as failed`
+        );
+        return;
+      }
+      const pushOutput = `${pushResult.stderr ?? ""}
+${pushResult.stdout ?? ""}`;
+      const pushError = pushOutput.toLowerCase();
+      const isNonFastForward = pushError.includes("non-fast-forward") || pushError.includes("fetch first") || pushError.includes("failed to push some refs");
+      if (!isNonFastForward || attempt === maxSyncAttempts) {
+        if (isMissingRemoteError(pushOutput)) {
+          warnOrThrowRemoteSync(
+            "Committed locally; no remote repository configured - push skipped"
+          );
+          return;
+        }
+        warnOrThrowRemoteSync(
+          `Committed locally but push failed: ${firstGitLine(pushResult.stderr ?? pushResult.stdout)}`
+        );
+        return;
+      }
+      const refreshedBoundary = await verifyManagedSyncPushBoundary(
+        projectRoot,
+        remote,
+        remoteBranch,
+        preSyncHeadSha,
+        true
+      );
+      if (!refreshedBoundary.ok) {
+        warnOrThrowRemoteSync(`Committed locally but ${refreshedBoundary.reason} - push skipped`);
+        return;
+      }
+    }
+  } catch (error) {
+    if (isManagedSyncBranchError(error)) {
+      await abandonManagedSyncStaging(projectRoot, stagingState);
+      throw error;
+    }
+    if (options.strict) {
+      throw error;
+    }
+    if (!options.silent) {
+      console.log(
+        chalk.yellow(
+          `  Auto-sync failed: ${error.message?.split("\n")[0] ?? "unknown error"}`
+        )
+      );
+    }
+  }
+}
+async function syncManagedItemFiles(projectRoot, filePaths, commitMessage, options = {}) {
+  if (options.sync === false) {
+    return;
+  }
+  if (isDeferSyncEnabled()) {
+    return;
+  }
+  await syncPlanningFiles(projectRoot, filePaths, commitMessage, {
+    silent: options.silent ?? false
+  });
+}
+
+// src/planning/team-visibility-read-model.ts
+import * as path2 from "path";
+function unavailable(reason) {
+  return { status: "unavailable", reason };
+}
+function available(value) {
+  return { status: "available", value };
+}
+function projectUpdateAge(updatedAt, nowMs) {
+  const updatedAtMs = Date.parse(updatedAt);
+  if (!Number.isFinite(updatedAtMs)) {
+    return unavailable("Task update timestamp is invalid");
+  }
+  if (updatedAtMs > nowMs) {
+    return unavailable("Task update timestamp is in the future");
+  }
+  return available(nowMs - updatedAtMs);
+}
+function projectActiveTeamWork(tasks, options = {}) {
+  const nowMs = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+  const branchesByTaskId = new Map(
+    (options.branches ?? []).filter((entry) => entry.branch.trim().length > 0).map((entry) => [entry.taskId, entry.branch.trim()])
+  );
+  return tasks.filter((task) => task.status === "in_progress").map((task) => {
+    const assignee = task.assignee?.trim();
+    const branch = branchesByTaskId.get(task.id);
+    return {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      assignee: assignee ? available(assignee) : unavailable("Task has no assignee"),
+      branch: branch ? available(branch) : unavailable("No branch evidence is associated with this task"),
+      updatedAt: task.updated_at,
+      updateAgeMs: projectUpdateAge(task.updated_at, nowMs)
+    };
+  });
+}
+function planningPathspecs(repoRoot) {
+  return Array.from(
+    new Set(
+      listEnabledBuckets(repoRoot).flatMap((bucket) => [
+        getBucketPathByKind(bucket.name, repoRoot),
+        getBucketArchivePathByKind(bucket.name, repoRoot)
+      ]).map((bucketPath) => path2.relative(repoRoot, bucketPath).replace(/\\/g, "/")).filter((bucketPath) => bucketPath.length > 0 && !bucketPath.startsWith("..")).sort()
+    )
+  );
+}
+async function queryUnpushedPlanningCommits(repoRoot, git) {
+  let pathspecs;
+  try {
+    pathspecs = planningPathspecs(repoRoot);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return unavailable(`Planning bucket paths are unavailable: ${message}`);
+  }
+  if (pathspecs.length === 0) {
+    return unavailable("No enabled planning bucket paths are configured");
+  }
+  try {
+    const upstream = await git(
+      ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
+      { cwd: repoRoot }
+    );
+    const upstreamRef = upstream.stdout.trim();
+    if (upstream.exitCode !== 0 || upstreamRef.length === 0) {
+      return unavailable("Current branch has no available upstream tracking ref");
+    }
+    const countResult = await git(
+      ["rev-list", "--count", `${upstreamRef}..HEAD`, "--", ...pathspecs],
+      { cwd: repoRoot }
+    );
+    const countText = countResult.stdout.trim();
+    const count = Number.parseInt(countText, 10);
+    if (countResult.exitCode !== 0 || !/^\d+$/.test(countText) || !Number.isSafeInteger(count) || count < 0) {
+      return unavailable("Git could not determine the unpushed planning commit count");
+    }
+    return available(count);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return unavailable(`Git evidence is unavailable: ${message}`);
+  }
+}
+async function queryPlanningSyncHealth(options) {
+  const lastSyncFailure = options.lastSyncFailure;
+  const failureMessage = lastSyncFailure?.message.trim();
+  return {
+    advisory: true,
+    deferSyncActive: options.deferSyncEnabled ?? isDeferSyncEnabled(),
+    unpushedPlanningCommits: await queryUnpushedPlanningCommits(
+      options.repoRoot,
+      options.git ?? execGit
+    ),
+    lastSyncFailure: lastSyncFailure && failureMessage ? available({ ...lastSyncFailure, message: failureMessage }) : unavailable("Planning sync failures are not persisted by the current sync path")
+  };
+}
+async function queryTeamVisibility(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const [work, syncHealth] = await Promise.all([
+    Promise.resolve(projectActiveTeamWork(options.tasks, { branches: options.branches, now })),
+    queryPlanningSyncHealth(options)
+  ]);
+  return { observedAt: now.toISOString(), work, syncHealth };
+}
+
+// src/planning/planning-workspace-envelope.ts
+var PLANNING_WORKSPACE_ENVELOPE_VERSION = "1.0.0";
+function unavailable2(error) {
+  return { state: "unavailable", reason: error instanceof Error ? error.message : String(error) };
+}
+async function defaultTeamVisibility() {
+  const tasks = await getAllTasks();
+  return queryTeamVisibility({
+    repoRoot: getPlanningRoot(),
+    tasks: tasks.map((task) => task.yaml)
+  });
+}
+async function buildPlanningWorkspaceEnvelopeV1(readers = {}) {
+  const [canonicalResult, visibilityResult] = await Promise.allSettled([
+    (readers.queryCanonical ?? queryCanonicalPlanningProjection)(),
+    (readers.queryTeamVisibility ?? defaultTeamVisibility)()
+  ]);
+  return {
+    schemaVersion: PLANNING_WORKSPACE_ENVELOPE_VERSION,
+    canonical: canonicalResult.status === "fulfilled" ? {
+      state: "available",
+      value: {
+        activeSprint: canonicalResult.value.activeSprint,
+        tasks: canonicalResult.value.tasks,
+        // Preserve Poetic order and whyIncluded; BB must not re-rank.
+        nextCandidates: canonicalResult.value.nextCandidates
+      }
+    } : unavailable2(canonicalResult.reason),
+    teamVisibility: visibilityResult.status === "fulfilled" ? { state: "available", value: visibilityResult.value } : unavailable2(visibilityResult.reason)
+  };
+}
+
+// src/planning/sprint-status-read-model.ts
+async function querySprintStatus(sprintId) {
+  let targetSprintId = sprintId;
+  if (!targetSprintId) {
+    const current = await getCurrentSprint();
+    if (!current) return null;
+    targetSprintId = current.yaml.id;
+  }
+  const [capacity, allTasks, activeSprints, archivedSprints, repositoryTasks] = await Promise.all([
+    calculateCapacity(targetSprintId),
+    listTasksInSprint(targetSprintId),
+    listSprints(false),
+    listSprints(true),
+    getAllTasks({ includeArchive: true })
+  ]);
+  const activeSprint = activeSprints.find((s) => s.id === targetSprintId);
+  const archivedSprint = archivedSprints.find((s) => s.id === targetSprintId);
+  const sprint = activeSprint ?? archivedSprint;
+  const archived = !activeSprint && Boolean(archivedSprint);
+  const missingTaskIds = allTasks.filter((t) => t.missing === true).map((t) => t.id);
+  const tasks = allTasks.filter((t) => t.missing !== true);
+  const tasksByStatus = {
+    todo: tasks.filter((t) => t.status === "todo"),
+    in_progress: tasks.filter((t) => t.status === "in_progress"),
+    review: tasks.filter((t) => t.status === "review"),
+    done: tasks.filter((t) => t.status === "done"),
+    blocked: tasks.filter((t) => t.status === "blocked"),
+    cancelled: tasks.filter((t) => t.status === "cancelled")
+  };
+  const activeDoneHours = tasksByStatus.done.reduce((sum, task) => sum + task.estimatedHours, 0);
+  const archivedDoneTasks = repositoryTasks.filter((result) => result.isArchived).map((result) => result.yaml).filter((task) => task.status === "done" && task.originalSprintId === targetSprintId);
+  const archivedDoneHours = archivedDoneTasks.reduce((sum, task) => sum + task.estimatedHours, 0);
+  const allDone = tasks.length > 0 && tasksByStatus.done.length === tasks.length;
+  const allTerminal = tasks.length > 0 && tasksByStatus.done.length + tasksByStatus.blocked.length + tasksByStatus.cancelled.length === tasks.length;
+  const readiness = computeSprintTerminalReadiness(allTasks);
+  const integrityClean = readiness.missingTaskIds.length === 0;
+  const closable = sprint?.status === "active" && readiness.ready;
+  return {
+    sprintId: targetSprintId,
+    name: sprint?.name ?? targetSprintId,
+    status: sprint?.status ?? "unknown",
+    archived,
+    startDate: sprint?.startDate,
+    endDate: sprint?.endDate,
+    goal: sprint?.goal,
+    capacity: {
+      allocatedHours: capacity.allocatedHours,
+      totalHours: capacity.totalHours,
+      utilizationPercent: capacity.utilizationPercent
+    },
+    completedCapacity: {
+      activeDoneHours,
+      archivedDoneHours,
+      totalDoneHours: activeDoneHours + archivedDoneHours,
+      archivedTaskCount: archivedDoneTasks.length
+    },
+    progress: {
+      todo: tasksByStatus.todo.length,
+      in_progress: tasksByStatus.in_progress.length,
+      review: tasksByStatus.review.length,
+      done: tasksByStatus.done.length,
+      blocked: tasksByStatus.blocked.length,
+      cancelled: tasksByStatus.cancelled.length,
+      total: tasks.length,
+      allDone,
+      allTerminal,
+      integrityClean,
+      closable
+    },
+    tasks: tasks.map((t) => ({
+      id: t.id,
+      title: t.title,
+      status: t.status,
+      estimatedHours: t.estimatedHours,
+      ...typeof t.expectedRuntimeMinutes === "number" && t.expectedRuntimeMinutes > 0 ? { expectedRuntimeMinutes: t.expectedRuntimeMinutes } : {},
+      resultArtifactPath: t.resultArtifactPath
+    })),
+    missingTaskIds
+  };
+}
+
+export {
+  runPlanningGit,
+  verifyRemoteSyncPush,
+  isRefspecPushTopology,
+  filterExistingRelativePaths,
+  isDeferSyncEnabled,
+  isMissingRemoteError,
+  ManagedSyncBranchError,
+  formatManagedSyncBranchError,
+  isManagedSyncBranchError,
+  assertManagedSyncBranch,
+  hasStagedChanges,
+  abandonManagedSyncStaging,
+  stageManagedSyncPaths,
+  verifyManagedSyncPushBoundary,
+  resolveManagedSyncPushCandidate,
+  syncPlanningFiles,
+  syncManagedItemFiles,
+  buildPlanningWorkspaceEnvelopeV1,
+  querySprintStatus
+};
+//# sourceMappingURL=chunk-F23DIWNN.js.map