@north-light/cli 0.0.0-stage → 0.3.413

package/dist/core/wake.js

@@ -0,0 +1 @@
+var p=Object.defineProperty;var s=(n,e)=>p(n,"name",{value:e,configurable:!0});import{CronExpressionParser as N}from"cron-parser";const T=6e4,O={s:1e3,m:6e4,h:36e5,d:864e5},v=/^\+?(?:\d+[smhd])+$/,w=/(\d+)([smhd])/g,I=/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,3}))?/,b=/^(Z|[+-]\d{2}(?::?\d{2})?)$/,A={"@yearly":"0 0 1 1 *","@annually":"0 0 1 1 *","@monthly":"0 0 1 * *","@weekly":"0 0 * * 0","@daily":"0 0 * * *","@midnight":"0 0 * * *","@hourly":"0 * * * *"};function f(n,e,t){return{error:{code:n,message:e,received:t}}}s(f,"whenError");function m(n,e,t){return{error:{code:n,message:e,received:t}}}s(m,"cadenceError");function y(n){if(!v.test(n))return null;let e=0;w.lastIndex=0;let t;for(;(t=w.exec(n))!==null;)e+=Number(t[1])*O[t[2]];return e}s(y,"parseDurationMs");function g(){return Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC"}s(g,"hostZone");function _(n){try{return new Intl.DateTimeFormat("en-US",{timeZone:n}),!0}catch{return!1}}s(_,"isValidZone");function S(n,e){const t=new Intl.DateTimeFormat("en-US",{timeZone:n,hourCycle:"h23",year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",second:"2-digit"}),r={};for(const u of t.formatToParts(new Date(e)))u.type!=="literal"&&(r[u.type]=u.value);return Date.UTC(Number(r.year),Number(r.month)-1,Number(r.day),Number(r.hour),Number(r.minute),Number(r.second))-e}s(S,"zoneOffsetMs");function U(n,e,t,r,c,u,i,a){const o=Date.UTC(n,e-1,t,r,c,u,i),d=S(a,o);let l=o-d;const h=S(a,l);return h!==d&&(l=o-h),l}s(U,"wallClockToUtc");function z(n){const e=I.exec(n);if(!e||e.index!==0)return null;const t=n.slice(e[0].length);return t===""?{zoned:!1,y:Number(e[1]),mo:Number(e[2]),d:Number(e[3]),h:Number(e[4]),mi:Number(e[5]),s:e[6]?Number(e[6]):0,ms:e[7]?Number(e[7].padEnd(3,"0")):0}:b.test(t)?{zoned:!0}:null}s(z,"classifyIso");function C(n,e){const t=n,r=n.trim(),c=e.now.getTime(),u=y(r);if(u!==null){const a=c+u;return a<=c?f("wake_in_past",'That resolves to now or the past. Use a positive future duration (e.g. "5m", "2h").',t):{fireAt:new Date(a).toISOString()}}const i=z(r);if(i){let a;if(i.zoned){const o=new Date(r);if(Number.isNaN(o.getTime()))return f("bad_when",`Not a valid ISO-8601 instant: "${t}".`,t);a=o.getTime()}else{const o=e.tz??g();if(!_(o))return f("unknown_zone",`Unknown time zone: "${o}". Use an IANA name (e.g. "America/New_York").`,e.tz??o);if(a=U(i.y,i.mo,i.d,i.h,i.mi,i.s,i.ms,o),Number.isNaN(a))return f("bad_when",`Not a valid date-time: "${t}".`,t)}return a<=c?f("wake_in_past","That time is now or in the past. Pick a future instant.",t):{fireAt:new Date(a).toISOString()}}return f("bad_when",`Could not parse "${t}". Use a duration ("5m", "1h30m"), a zoned ISO ("2026-06-07T09:00:00Z"), or a bare ISO ("2026-06-07T09:00").`,t)}s(C,"parseWhen");function E(n,e){const t=n,r=n.trim(),c=e.now.getTime(),u=y(r);if(u!==null)return u<T?m("cadence_too_fast",'Interval too fast: minimum cadence is 60s. Use a longer --every (e.g. "1m", "5m", "1h").',t):{recur:JSON.stringify({every:r}),firstFireAt:new Date(c+u).toISOString()};const i=A[r]??r,a=e.tz??g();if(e.tz!==void 0&&!_(e.tz))return m("unknown_zone",`Unknown time zone: "${e.tz}". Use an IANA name (e.g. "America/New_York").`,e.tz);let o,d;try{o=N.parse(i,{currentDate:e.now,tz:a}),d=o.next().toDate().toISOString()}catch{return m("bad_cadence",`Could not parse cadence "${t}". Use a duration ("6h"), a 5-field cron ("0 9 * * *"), or an @alias ("@daily").`,t)}const l=o.fields?.second;return(l&&Array.isArray(l.values)?l.values:[0]).length>1?m("cadence_too_fast","Cron resolves below the 60s floor (sub-minute spacing). Use a cadence of at least one minute.",t):{recur:JSON.stringify({cron:i,tz:a}),firstFireAt:d}}s(E,"parseCadence");function $(n){if(n==null)return"none";try{const e=JSON.parse(n);if(typeof e.every=="string")return`every ${e.every}`;if(typeof e.cron=="string")return`cron \`${e.cron}\`${typeof e.tz=="string"?` (${e.tz})`:""}`}catch{}return"none"}s($,"cadenceDisplay");function k(n,e){let t;try{t=JSON.parse(n)}catch{throw new Error(`nextSlotAfter: malformed recur JSON: ${n}`)}if(typeof t.every=="string"){const r=y(t.every);if(r===null||r<=0)throw new Error(`nextSlotAfter: invalid interval recur: ${n}`);return new Date(e.getTime()+r).toISOString()}if(typeof t.cron=="string"){const r=typeof t.tz=="string"?t.tz:"UTC";return N.parse(t.cron,{currentDate:e,tz:r}).next().toDate().toISOString()}throw new Error(`nextSlotAfter: recur has neither 'every' nor 'cron': ${n}`)}s(k,"nextSlotAfter");export{T as CADENCE_FLOOR_MS,$ as cadenceDisplay,k as nextSlotAfter,E as parseCadence,y as parseDurationMs,C as parseWhen};

package/dist/core/worktree-close.d.ts

@@ -0,0 +1,4 @@
+import { type CloseManagedWorktreeResult } from './worktree.js';
+/** Async daemon executor for explicit close. The lock wait and every Git
+ * subprocess yield to the daemon event loop. */
+export declare function closeManagedWorktreeAsync(nodeId: string): Promise<CloseManagedWorktreeResult>;

package/dist/core/worktree-close.js

@@ -0,0 +1,6 @@
+var P=Object.defineProperty;var c=(t,r)=>P(t,"name",{value:r,configurable:!0});import{existsSync as $,realpathSync as R}from"node:fs";import{resolve as q}from"node:path";import{getNode as v,recordDisposalGrant as B,recordLandIntent as M}from"./canvas/index.js";import{withExclusiveDirectoryLockAsync as O}from"./exclusive-lock.js";import{gitAsync as i}from"./git.js";import{proveBranchContained as x}from"./worktree-containment.js";import{concludeAbsentManagedWorktreeAsync as F}from"./worktree-mutation-async.js";import{parseStatusPorcelain as G,planLandIntoCheckout as I}from"./worktree-landing.js";import{WORKTREE_LOCK_WAIT_MS as T,checkoutPathForBranchInList as N,missingWorktreeRecoveryHint as j,persistClosedWorktreeState as A,samePath as K,worktreeLockPathForCommonDir as z,WorktreeError as h}from"./worktree.js";import{shellQuote as E}from"../shared/shell-quote.js";function p(t){return(t.stderr.trim()||t.stdout.trim()).trim()}c(p,"detailOf");async function u(t,r,e,o){const a=await i(r,t);if(a.status!==0)throw new h(e,`git ${r.join(" ")} failed`,o,p(a));return a.stdout.trim()}c(u,"runGit");async function H(t){const r=await u(t,["rev-parse","--git-common-dir"],"git_common_dir_failed","Inspect the repository git metadata, then retry.");return R(q(t,r))}c(H,"commonGitDir");async function Q(t,r){const e=`refs/heads/${r}`,o=await i(["show-ref","--verify","--quiet",e],t);if(o.status===1&&o.executionFailed!==!0)throw new h("missing_base_branch",`managed worktree base '${r}' does not name an existing local branch`,"The base must be a local branch that landing can fast-forward \u2014 freshen your local branch from origin first (rebase-not-merge), then base on it.");if(o.status!==0){const a=o.processError===void 0?"":`
+process error: ${o.processError}`;throw new h("base_branch_inspection_failed",`could not inspect local base branch '${r}' (git show-ref exited with status ${o.status})`,"Inspect the repository and its Git metadata, then retry.",`status: ${o.status}
+stderr: ${o.stderr.trim()||"<empty>"}${a}`)}return u(t,["rev-parse","--verify",e],"base_branch_resolve_failed","Inspect the local base branch, then retry.")}c(Q,"resolveLandableBase");async function J(t){for(const r of["rebase-merge","rebase-apply"]){const e=await u(t,["rev-parse","--git-path",r],"git_path_failed","Inspect the worktree manually, then retry.");if($(e))return!0}return!1}c(J,"rebaseInProgress");async function L(t,r,e){const o=await i(["worktree","list","--porcelain"],t);if(o.status!==0)return!1;let a=null;for(const n of o.stdout.split(`
+`))if(n.startsWith("worktree "))a=n.slice(9).trim();else if(a!==null&&K(a,r)&&n===`branch refs/heads/${e}`)return!0;return!1}c(L,"registeredWorktree");function D(t){return{worktree_removed:!1,worktree_remove_error:`cleanup pending: the caller checkout at ${t.path} remains intact. After its node exits, run \`git -C ${E(t.repo_root)} worktree remove ${E(t.path)}\` after confirming it is safe to delete.`,branch_deleted:!1,branch_delete_error:`cleanup pending: local branch ${t.branch} remains checked out at ${t.path}; delete it only after that checkout is removed and its landed commit is still contained in ${t.base_ref}.`}}c(D,"deferredCleanupResult");function U(t,r){const e=v(t)?.managed_worktree;e==null||e.state!=="open"||M(t,{at:new Date().toISOString(),blocked:r})}c(U,"recordBlockedLandIntent");async function W(t,r){const e=await i(["rev-parse","--verify","--quiet","refs/stash"],t);e.status===0&&e.stdout.trim()===r&&await i(["stash","drop"],t)}c(W,"dropStashIfStillTip");async function V(t,r,e,o){const a=await i(["status","--porcelain"],t);if(a.status!==0)return{ok:!1,detail:p(a)};const n=await i(["diff","--name-only",e,o],t);if(n.status!==0)return{ok:!1,detail:p(n)};const f=n.stdout.split(`
+`).map(_=>_.trim()).filter(_=>_!==""),k=I(G(a.stdout),f);if(k.kind==="refuse")return{ok:!1,detail:`untracked files in ${t} would be overwritten by the incoming commits: ${k.collisions.join(", ")}`};const w=c(async()=>{const _=await i(["merge","--ff-only",o],t);return _.status===0?{ok:!0}:{ok:!1,detail:p(_)}},"merge");if(k.kind==="direct")return w();const b=await i(["rev-parse","--verify","--quiet","refs/stash"],t),g=b.status===0?b.stdout.trim():null,y=await i(["stash","push","--message",`crtr landing ${r}`],t);if(y.status!==0)return{ok:!1,detail:p(y)};const m=await i(["rev-parse","--verify","--quiet","refs/stash"],t),l=m.status===0?m.stdout.trim():null;if(l===null||l===g)return w();const s=`local changes from ${t} are retained in stash ${l}; recover them with \`git -C ${E(t)} stash apply ${l}\` and resolve any conflict.`,d=await w();return d.ok?(await i(["stash","apply",l],t)).status===0?(await W(t,l),{ok:!0}):(await i(["reset","--hard",o],t),{ok:!0,stash:`the shared base checkout was reset to landed commit ${o} because local changes conflicted with it. ${s}`}):(await i(["stash","apply",l],t)).status===0?(await W(t,l),d):{ok:!1,detail:`${d.detail}
+${s}`}}c(V,"landIntoBaseCheckout");async function S(t){const r=v(t);if(r===null)throw new h("unknown_node",`unknown node: ${t}`,"Run this from a live node, or pass a real node id once that command supports it.");const e=r?.managed_worktree?.state==="open"?r.managed_worktree:null;if(e===null)throw new h("no_managed_worktree",`node ${t} has no open managed worktree`,"Nothing to close for this node.");if(!$(e.path))throw new h("worktree_missing",`managed worktree path is missing: ${e.path}`,j(e));if(await J(e.path))throw new h("rebase_in_progress","this managed worktree is mid-rebase",`Resolve conflicts in ${e.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree close\`.`);if(await u(e.path,["status","--porcelain"],"status_failed","Inspect the worktree manually, then retry.")!=="")throw new h("dirty_worktree","managed worktree has uncommitted changes",`Commit the work in ${e.path}, then rerun \`crtr node worktree close\`.`);const a=await u(e.path,["rev-parse","--abbrev-ref","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry."),n=await u(e.path,["rev-parse","HEAD"],"landed_sha_failed","Inspect the worktree checkout manually, then rerun `crtr node worktree close`.");if(a!==e.branch){if((await i(["show-ref","--verify","--quiet",`refs/heads/${e.branch}`],e.path)).status===0||a==="HEAD"||!await L(e.repo_root,e.path,a))throw new h("wrong_branch",`managed worktree is not on its recorded branch (expected ${e.branch}, found ${a==="HEAD"?"detached HEAD":a})`,`Inspect ${e.path}, then rerun \`crtr node worktree close\`.`);if(await x(e.path,e,n)===null)throw new h("branch_moved_unlanded",`managed worktree's recorded branch ${e.branch} no longer exists; its checkout is now on ${a} at ${n}, which carries content local base branch '${e.base_ref}' does not yet contain`,`Land or push ${a} through its own workflow before closing.`);const d=await H(e.path);if(!await L(e.repo_root,e.path,a)||await u(e.path,["rev-parse","--abbrev-ref","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry.")!==a||await u(e.path,["rev-parse","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry.")!==n)throw new h("wrong_branch",`managed worktree at ${e.path} changed while closing`,`Inspect ${e.path}, then rerun \`crtr node worktree close\`.`);return B(t,{observed_branch:a,observed_sha:n,common_dir:d,authorized:new Date().toISOString()}),A(t,e,"pending"),{node_id:t,branch:a,worktree_path:e.path,landed_sha:n,...D(e),branch_delete_error:`${a} is not a crtr-managed branch and will never be deleted automatically; it is preserved once the checkout above is removed.`}}if(await x(e.path,e,n)!==null)return A(t,e,"pending"),{node_id:t,branch:e.branch,worktree_path:e.path,landed_sha:n,...D(e)};let f;try{f=await Q(e.path,e.base_ref)}catch(s){if(!(s instanceof h)||s.code!=="missing_base_branch"||n!==e.base_sha)throw s;return A(t,e,"pending"),{node_id:t,branch:e.branch,worktree_path:e.path,landed_sha:e.base_sha,...D(e)}}const k=await i(["rebase",f],e.path);if(k.status!==0)throw new h("rebase_failed",`rebase onto local base branch '${e.base_ref}' did not complete`,`Resolve conflicts in ${e.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree close\`.`,p(k));const w=await u(e.path,["rev-parse","HEAD"],"landed_sha_failed","Inspect the worktree checkout manually, then rerun `crtr node worktree close`."),b=c((s,d,_)=>(U(t,s),new h("land_base_failed",s,d,_)),"blocked"),g=await i(["merge-base","--is-ancestor",f,w],e.path);if(g.status!==0)throw b(`rebased worktree is not a fast-forward of local base branch '${e.base_ref}'`,"Ask the user how to land this managed worktree.",p(g));const y=await u(e.path,["worktree","list","--porcelain"],"worktree_list_failed","Inspect the repository worktrees manually, then retry."),m=N(y,e.base_ref);let l;if(m!==null){const s=await i(["rev-parse","HEAD"],m);if(s.status!==0||s.stdout.trim()!==f)throw b(`local base branch '${e.base_ref}' changed while this worktree was closing`,`Reconcile the base checkout at ${m}, then rerun \`crtr node worktree close\`.`,s.status!==0?p(s):`expected ${f}, found ${s.stdout.trim()}`);const d=await V(m,e.branch,f,w);if(!d.ok)throw b(`could not fast-forward local base branch '${e.base_ref}' to this worktree`,`Local base branch '${e.base_ref}' is checked out at ${m} in a state that blocks a fast-forward.`,d.detail);l=d.stash}else{const s=await i(["update-ref",`refs/heads/${e.base_ref}`,w,f],e.path);if(s.status!==0)throw b(`could not fast-forward local base branch '${e.base_ref}' to this worktree`,"Ask the user how to land this managed worktree.",p(s))}return A(t,e,"pending"),{node_id:t,branch:e.branch,worktree_path:e.path,landed_sha:w,...D(e),...l===void 0?{}:{base_checkout_stash:l}}}c(S,"closeLocked");async function ie(t){const r=v(t)?.managed_worktree;if(r==null||r.state!=="open")return S(t);if(!$(r.path)){const n=await F(t);if(n!==null)return{node_id:t,branch:n.dropped.branch,worktree_path:n.dropped.worktree_path,landed_sha:n.landedSha,worktree_removed:!0,branch_deleted:n.dropped.branch_deleted,...n.dropped.branch_delete_error===void 0?{}:{branch_delete_error:n.dropped.branch_delete_error}}}const e=v(t)?.managed_worktree;if(e==null||e.state!=="open")return S(t);const o=$(e.path)?e.path:e.repo_root,a=await H(o);return O(z(a),()=>S(t),{timeoutMs:Math.min(T,25e3),timeoutError:c(()=>new h("worktree_lock_timeout",`timed out waiting to create a managed worktree in ${a}`,"Wait for the other managed-worktree operation to finish, then retry."),"timeoutError")})}c(ie,"closeManagedWorktreeAsync");export{ie as closeManagedWorktreeAsync};

package/dist/core/worktree-containment.d.ts

@@ -0,0 +1,14 @@
+import type { ManagedWorktree } from './canvas/index.js';
+export interface BranchContainmentProof {
+    containingRef: string;
+    containingSha: string;
+}
+/** Resolve the base branch's configured upstream, or its origin fallback. */
+export declare function upstreamTip(cwd: string, baseRef: string): Promise<{
+    ref: string;
+    sha: string;
+} | null>;
+/** Prove that a recorded base or its upstream already carries a branch's
+ * committed content. This is the one decision point for explicit close and
+ * sweep cleanup: destination resolution happens only when this returns null. */
+export declare function proveBranchContained(cwd: string, wt: Pick<ManagedWorktree, 'base_ref'>, branchSha: string): Promise<BranchContainmentProof | null>;

package/dist/core/worktree-containment.js

@@ -0,0 +1,3 @@
+var p=Object.defineProperty;var f=(t,n)=>p(t,"name",{value:n,configurable:!0});import{gitAsync as u}from"./git.js";async function l(t,n){const s=await u(["rev-parse","--verify","--quiet",n],t);return s.status===0?s.stdout.trim():null}f(l,"revParseRef");async function d(t,n){const s=await u(["rev-parse","--symbolic-full-name","--verify",`${n}@{upstream}`],t),a=s.status===0&&s.stdout.trim().startsWith("refs/")?s.stdout.trim():`refs/remotes/origin/${n}`,r=await l(t,a);return r===null?null:{ref:a,sha:r}}f(d,"upstreamTip");async function v(t,n,s){const a=[],r=`refs/heads/${n.base_ref}`,m=await l(t,r);m!==null&&a.push({ref:r,sha:m});const h=await d(t,n.base_ref);h!==null&&a.push(h);for(const e of a)if((await u(["merge-base","--is-ancestor",s,e.sha],t)).status===0)return{containingRef:e.ref,containingSha:e.sha};for(const e of a){const i=await u(["cherry",e.sha,s],t);if(i.status!==0)continue;if(i.stdout.split(`
+`).map(o=>o.trim()).filter(o=>o!=="").every(o=>o.startsWith("-")))return{containingRef:e.ref,containingSha:e.sha}}for(const e of a){const i=await l(t,`${e.sha}^{tree}`);if(i===null)continue;const c=await u(["merge-tree","--write-tree",e.sha,s],t);if(c.status===0&&c.stdout.split(`
+`)[0]?.trim()===i)return{containingRef:e.ref,containingSha:e.sha}}return null}f(v,"proveBranchContained");export{v as proveBranchContained,d as upstreamTip};

package/dist/core/worktree-landing.d.ts

@@ -0,0 +1,44 @@
+/** Tracked-but-modified and untracked paths from `git status --porcelain`. */
+export interface CheckoutStatus {
+    /** Paths with modifications to a tracked file (staged, unstaged, or both). */
+    tracked: string[];
+    /** Paths Git does not track at all. */
+    untracked: string[];
+}
+/** Split `git status --porcelain` (v1 format) into tracked modifications and
+ *  untracked paths. A rename entry (`R  old -> new`) reports the destination:
+ *  that is the path an incoming commit would collide with. */
+export declare function parseStatusPorcelain(porcelain: string): CheckoutStatus;
+export type LandPlan = 
+/** Nothing local overlaps the incoming commits — fast-forward directly. */
+{
+    kind: 'direct';
+}
+/** Local modifications touch incoming files; land underneath them. */
+ | {
+    kind: 'stash';
+    overlapping: string[];
+}
+/** An incoming commit adds a path that already exists here, untracked. */
+ | {
+    kind: 'refuse';
+    collisions: string[];
+};
+/** How to fast-forward a base checkout that may hold local changes.
+ *
+ *  Git is less fragile than it looks here: a fast-forward refuses only when an
+ *  incoming commit touches a file with local modifications, so DISJOINT local
+ *  changes are carried along fine and need no stash at all. Overlap is the
+ *  blocker, not dirt.
+ *
+ *  Untracked files are different. They also do not block a fast-forward unless
+ *  an incoming commit adds the same path — and that collision is a refusal
+ *  rather than a stash, because sweeping a person's untracked file into a stash
+ *  to make room for a commit is not a trade this code may make on their behalf. */
+export declare function planLandIntoCheckout(status: CheckoutStatus, incoming: readonly string[]): LandPlan;
+/** The `git update-ref --stdin` body that deletes a managed branch ONLY while
+ *  the ref that proved its content already landed is still at the exact SHA the
+ *  proof inspected. Compare-and-delete is the whole ownership guard: a branch
+ *  or base someone else moved between the proof and this transaction aborts it
+ *  instead of losing the work. */
+export declare function refDeleteTransactionStdin(branch: string, branchSha: string, containingRef: string, containingSha: string): string;

package/dist/core/worktree-landing.js

@@ -0,0 +1,4 @@
+var a=Object.defineProperty;var o=(e,n)=>a(e,"name",{value:n,configurable:!0});function u(e){const n=[],s=[];for(const t of e.split(`
+`)){if(t.length<4)continue;const r=t.slice(0,2),i=t.slice(3),c=i.includes(" -> ")?i.slice(i.indexOf(" -> ")+4):i,l=c.startsWith('"')&&c.endsWith('"')?c.slice(1,-1):c;r==="??"?s.push(l):r!=="!!"&&n.push(l)}return{tracked:n,untracked:s}}o(u,"parseStatusPorcelain");function f(e,n){const s=new Set(n),t=e.untracked.filter(i=>s.has(i));if(t.length>0)return{kind:"refuse",collisions:t};const r=e.tracked.filter(i=>s.has(i));return r.length>0?{kind:"stash",overlapping:r}:{kind:"direct"}}o(f,"planLandIntoCheckout");function h(e,n,s,t){return`verify ${s} ${t}
+delete refs/heads/${e} ${n}
+`}o(h,"refDeleteTransactionStdin");export{u as parseStatusPorcelain,f as planLandIntoCheckout,h as refDeleteTransactionStdin};

package/dist/core/worktree-mutation-async.d.ts

@@ -0,0 +1,13 @@
+import { type ManagedWorktree } from './canvas/index.js';
+import { type AbandonManagedWorktreeResult, type AutoDroppedWorktree } from './worktree.js';
+export declare function rollbackManagedWorktreeAsync(wt: ManagedWorktree): Promise<void>;
+export declare function createManagedWorktreeAsync(cwd: string, nodeId: string, baseRef?: string): Promise<ManagedWorktree>;
+export interface AbsentWorktreeConclusion {
+    dropped: AutoDroppedWorktree;
+    landedSha: string;
+}
+/** Conclude an absent checkout only from the same branch-delivery proof used by
+ * push-final and explicit close. */
+export declare function concludeAbsentManagedWorktreeAsync(nodeId: string): Promise<AbsentWorktreeConclusion | null>;
+export declare function autoDropCleanManagedWorktreeAsync(nodeId: string): Promise<AutoDroppedWorktree | null>;
+export declare function abandonManagedWorktreeAsync(nodeId: string, by: string): Promise<AbandonManagedWorktreeResult>;

package/dist/core/worktree-mutation-async.js

@@ -0,0 +1,10 @@
+var P=Object.defineProperty;var o=(e,r)=>P(e,"name",{value:r,configurable:!0});import{existsSync as p,mkdirSync as H,readFileSync as R,realpathSync as O,rmSync as B,writeFileSync as q}from"node:fs";import{dirname as N,join as j,resolve as G}from"node:path";import{abandonWorktreeAndRepoint as I,getNode as w}from"./canvas/index.js";import{isPidAlive as K}from"./canvas/pid.js";import{CONFIG_FILE as z,CRTR_DIR_NAME as x,STATE_FILE as J}from"../types.js";import{withExclusiveDirectoryLockAsync as S}from"./exclusive-lock.js";import{gitAsync as s}from"./git.js";import{WORKTREE_LOCK_WAIT_MS as Q,checkoutPathForBranchInList as U,isManagedWorktreeBase as V,managedWorktreePath as X,persistClosedWorktreeState as _,worktreeLockPathForCommonDir as D,WorktreeError as c}from"./worktree.js";import{proveBranchContained as Y}from"./worktree-containment.js";import{refDeleteTransactionStdin as Z}from"./worktree-landing.js";import{deleteTrashAsync as ee,removeWorktreeCheckoutAsync as te}from"./worktree-remove.js";const E=Math.min(Q,25e3);function v(e){return(e.stderr.trim()||e.stdout.trim()).trim()}o(v,"detailOf");async function h(e,r,a,n){const t=await s(r,e);if(t.status!==0)throw new c(a,`git ${r.join(" ")} failed`,n,v(t));return t.stdout.trim()}o(h,"runGit");async function W(e){return O(G(e,await h(e,["rev-parse","--git-common-dir"],"git_common_dir_failed","Inspect the repository git metadata, then retry.")))}o(W,"commonGitDir");async function k(e,r){const a=await W(e);return S(D(a),r,{timeoutMs:E,timeoutError:o(()=>new c("worktree_lock_timeout",`timed out waiting to create a managed worktree in ${a}`,"Wait for the other managed-worktree operation to finish, then retry."),"timeoutError")})}o(k,"withRepositoryLock");async function $(e,r){const a=`refs/heads/${r}`,n=await s(["show-ref","--verify","--quiet",a],e);if(n.status===1&&n.executionFailed!==!0)throw new c("missing_base_branch",`managed worktree base '${r}' does not name an existing local branch`,"The base must be a local branch that landing can fast-forward \u2014 freshen your local branch from origin first (rebase-not-merge), then base on it.");if(n.status!==0)throw new c("base_branch_inspection_failed",`could not inspect local base branch '${r}' (git show-ref exited with status ${n.status})`,"Inspect the repository and its Git metadata, then retry.",`status: ${n.status}
+stderr: ${n.stderr.trim()||"<empty>"}`);return h(e,["rev-parse","--verify",a],"base_branch_resolve_failed","Inspect the local base branch, then retry.")}o($,"resolveLandableBase");function re(e,r){try{const a=j(r,"info","exclude");H(N(a),{recursive:!0});let n="";try{n=R(a,"utf8")}catch{}const t=[`/${x}/${z}`,`/${x}/${J}`];if(t.every(i=>n.split(`
+`).map(l=>l.trim()).includes(i)))return;q(a,`${n}${n!==""&&!n.endsWith(`
+`)?`
+`:""}# crtr: exclude crtr's own untracked project-scope bookkeeping (auto-added at managed-worktree creation)
+${t.filter(i=>!n.split(`
+`).map(l=>l.trim()).includes(i)).join(`
+`)}
+`)}catch{}}o(re,"seedExclude");async function ye(e){await k(e.repo_root,async()=>{const r=await s(["rev-parse","--verify",`refs/heads/${e.branch}`],e.repo_root);if(r.status!==0||r.stdout.trim()!==e.base_sha)return;const a=await s(["worktree","list","--porcelain"],e.repo_root);if(a.status===0){if(a.stdout.split(`
+`).some(n=>n.trim()===`branch refs/heads/${e.branch}`)){if((await s(["worktree","remove","--force",e.path],e.repo_root)).status!==0)return}else if(p(e.path))try{B(e.path,{recursive:!0,force:!0})}catch{return}await s(["update-ref","-d",`refs/heads/${e.branch}`,e.base_sha],e.repo_root)}})}o(ye,"rollbackManagedWorktreeAsync");async function ge(e,r,a="main"){const n=await h(e,["rev-parse","--show-toplevel"],"not_git_repo","Pass --cwd <real repo> pointing inside a git repository.");if(V(n))throw new c("managed_worktree_base",`cwd ${n} is a managed worktree and cannot be used as a managed worktree base`,"Pass `--cwd` pointing at the repository\u2019s primary checkout and keep `--worktree` set to the desired existing local base branch, including the parent branch.");const t=await W(n);return S(D(t),async()=>{const i=await $(n,a),l=X(r),u=`crtr/${r}`;if(p(l))throw new c("worktree_path_exists",`managed worktree path already exists: ${l}`,"Remove the stale path or choose a fresh node id.");if((await s(["show-ref","--verify","--quiet",`refs/heads/${u}`],n)).status===0)throw new c("worktree_branch_exists",`managed worktree branch already exists: ${u}`,"Remove the stale branch or choose a fresh node id.");const b={state:"open",path:l,branch:u,repo_root:n,base_ref:a,base_sha:i,created:new Date().toISOString()};await h(n,["branch",u,i],"worktree_branch_create_failed","Inspect the git error, fix the repository/worktree state, then retry spawning with --worktree.");const f=await s(["worktree","add",l,u],n);if(f.status!==0)throw await s(["update-ref","-d",`refs/heads/${u}`,i],n),new c("worktree_add_failed","git worktree add failed","Inspect the git error, fix the repository/worktree state, then retry spawning with --worktree.",v(f));return re(n,t),b},{timeoutMs:E,timeoutError:o(()=>new c("worktree_lock_timeout",`timed out waiting to create a managed worktree in ${t}`,"Wait for the other managed-worktree operation to finish, then retry."),"timeoutError")})}o(ge,"createManagedWorktreeAsync");async function M(e){if(e.state!=="open"||!p(e.path))return null;const r=await s(["rev-parse","--abbrev-ref","HEAD"],e.path),a=await s(["status","--porcelain"],e.path),n=await s(["rev-parse","HEAD"],e.path);if(r.status!==0||r.stdout.trim()!==e.branch||a.status!==0||a.stdout.trim()!==""||n.status!==0)return null;const t=await s(["rev-parse","--git-path","rebase-merge"],e.path);return t.status!==0||p(t.stdout.trim())?null:n.stdout.trim()}o(M,"cleanTip");async function C(e,r){try{const a=await $(e.path,e.base_ref);return(await s(["merge-base","--is-ancestor",r,a],e.path)).status===0}catch(a){if(a instanceof c&&a.code==="missing_base_branch"&&r===e.base_sha)return!0;throw a}}o(C,"containedInLocalBase");function ae(e){return{node_id:"",branch:e.branch,worktree_path:e.path,worktree_removed:!1,worktree_remove_error:`cleanup pending: the caller checkout at ${e.path} remains intact.`,branch_deleted:!1,branch_delete_error:`cleanup pending: local branch ${e.branch} remains checked out at ${e.path}.`}}o(ae,"deferred");async function L(e){if(e.state!=="open"||p(e.path))return null;const r=`refs/heads/${e.branch}`,a=await s(["show-ref","--verify","--quiet",r],e.repo_root);if(a.status===1&&a.executionFailed!==!0)return{branchSha:null};if(a.status!==0)return null;const n=await s(["rev-parse","--verify",r],e.repo_root);if(n.status!==0)return null;const t=n.stdout.trim(),i=await s(["worktree","list","--porcelain"],e.repo_root);if(i.status!==0||U(i.stdout,e.branch)!==null)return null;const l=await Y(e.repo_root,e,t);return l===null?null:{branchSha:t,containment:l}}o(L,"proveAbsentPathManagedWorktree");async function ne(e,r,a){return p(r.path)?null:a.branchSha===null?(_(e,r,"complete"),{node_id:e,branch:r.branch,worktree_path:r.path,worktree_removed:!0,branch_deleted:!0}):a.containment===void 0?null:(_(e,r,"complete"),{node_id:e,branch:r.branch,worktree_path:r.path,worktree_removed:!0,branch_deleted:!1,branch_delete_error:`local branch ${r.branch} is delivered but retained because its checkout status can change outside crtr's repository lock.`})}o(ne,"autoDropAbsentPathManagedWorktreeLocked");async function oe(e){const r=w(e)?.managed_worktree;return r==null||r.state!=="open"||p(r.path)||await L(r)===null?null:k(r.repo_root,async()=>{const a=w(e)?.managed_worktree;if(a==null||a.state!=="open")return null;const n=await L(a);if(n===null)return null;const t=await ne(e,a,n);return t===null?null:{dropped:t,landedSha:n.branchSha??a.base_sha}})}o(oe,"concludeAbsentManagedWorktreeAsync");async function ve(e){const r=w(e)?.managed_worktree;if(r==null||r.state!=="open")return null;if(!p(r.path))return(await oe(e))?.dropped??null;const a=await M(r);return a===null||!await C(r,a)?null:k(r.path,async()=>{const n=w(e)?.managed_worktree;if(n==null||n.state!=="open")return null;const t=await M(n);return t===null||t!==a||!await C(n,t)?null:(_(e,n,"pending"),{...ae(n),node_id:e})})}o(ve,"autoDropCleanManagedWorktreeAsync");async function T(e){for(const r of["rebase-merge","rebase-apply"]){const a=await s(["rev-parse","--git-path",r],e);if(a.status!==0||p(a.stdout.trim()))return!0}return!1}o(T,"rebaseInProgress");function y(e,r,a,n,t,i=r.branch){I(e,{cwd:r.repo_root,abandoned:{branch:i,tip_sha:a,at:n,by:t}})}o(y,"persistAbandoned");async function $e(e,r){const a=w(e)?.managed_worktree;if(a==null||a.state!=="open")throw new c("no_managed_worktree",`node ${e} has no open managed worktree`,"Nothing to abandon for this node.");const n=[];try{return await k(a.path,()=>se(e,r,n))}finally{await ee(a.path,n[0])}}o($e,"abandonManagedWorktreeAsync");async function g(e,r){const{result:a,trash:n}=await te(e.repo_root,e.path);if(n!==void 0&&r.push(n),a.status!==0)throw new c("worktree_remove_failed",`git worktree remove ${e.path} failed`,"Inspect the worktree manually, then retry.",v(a))}o(g,"removeCheckout");async function se(e,r,a){const n=w(e),t=n?.managed_worktree;if(n===null||t===void 0||t===null||t.state!=="open")throw new c("no_managed_worktree",`node ${e} has no open managed worktree`,"Nothing to abandon for this node.");if(n.status==="active"||n.status==="idle"||K(n.pi_pid))throw new c("node_running",`node ${e} is still running`,"Abandon requires a stopped node with no live broker process. From the running owner, use `crtr node worktree close` to land locally, or make the checkout clean, push its current tip to origin, and rerun `crtr push final`.");if(!p(t.path))throw new c("worktree_missing",`managed worktree path is missing: ${t.path}`,"Inspect the branch and worktree registration, then retry.");const i=await h(t.path,["rev-parse","--abbrev-ref","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry."),l=await s(["show-ref","--verify","--quiet",`refs/heads/${t.branch}`],t.path);if(i!==t.branch){if(l.status===0||i==="HEAD")throw new c("wrong_branch",`managed worktree is not on its recorded branch (expected ${t.branch}, found ${i==="HEAD"?"detached HEAD":i})`,`Inspect ${t.path}, then rerun \`crtr node worktree abandon\`.`);if(await T(t.path)||await h(t.path,["status","--porcelain"],"status_failed","Inspect the worktree manually, then retry.")!=="")throw new c("dirty_worktree","managed worktree has uncommitted changes",`Commit or stash them in ${t.path}, then rerun \`crtr node worktree abandon\`.`);const d=await h(t.path,["rev-parse","HEAD"],"abandon_tip_failed","Inspect the worktree manually, then retry.");await g(t,a);const m=new Date().toISOString();return y(e,t,d,m,r,i),{node_id:e,branch:i,tip_sha:d,worktree_path:t.path,branch_deleted:!1}}const u=await h(t.path,["rev-parse","HEAD"],"abandon_tip_failed","Inspect the branch manually, then retry.");let b=null;try{const d=await $(t.path,t.base_ref);(await s(["merge-base","--is-ancestor",u,d],t.path)).status===0&&(b=d)}catch(d){if(!(d instanceof c)||d.code!=="missing_base_branch")throw d}const f=new Date().toISOString(),F=await h(t.path,["status","--porcelain"],"status_failed","Inspect the worktree manually, then retry.");if(b!==null&&u===t.base_sha){const d=await h(t.repo_root,["rev-parse",`${u}^{tree}`],"abandon_tree_failed","Inspect the branch manually, then retry."),m=await h(t.repo_root,["-c","user.name=crtr-abandon","-c","user.email=crtr-abandon@localhost","commit-tree",d,"-p",u,"-m","crtr-abandon","-m",`Crtr-Abandon: ${e} ${f}`],"abandon_commit_failed","Inspect the branch manually, then retry.");return await h(t.repo_root,["update-ref",`refs/heads/${t.branch}`,m,u],"abandon_marker_failed","The branch changed while abandon was starting; inspect the worktree, then retry."),await g(t,a),(await s(["update-ref","--stdin"],t.repo_root,Z(t.branch,m,`refs/heads/${t.base_ref}`,b))).status===0?(_(e,t,"complete"),{node_id:e,branch:t.branch,tip_sha:m,worktree_path:t.path,branch_deleted:!0}):(y(e,t,m,f,r),{node_id:e,branch:t.branch,tip_sha:m,worktree_path:t.path,branch_deleted:!1})}if(!await T(t.path)&&F==="")return await g(t,a),y(e,t,u,f,r),{node_id:e,branch:t.branch,tip_sha:u,worktree_path:t.path,branch_deleted:!1};await h(t.path,["add","--all"],"abandon_stage_failed","Inspect the worktree manually, then retry."),await h(t.path,["-c","user.name=crtr-abandon","-c","user.email=crtr-abandon@localhost","commit","--allow-empty","-m","crtr-abandon","-m",`Crtr-Abandon: ${e} ${f}`],"abandon_commit_failed","Inspect the worktree manually, then retry.");const A=await h(t.path,["rev-parse","HEAD"],"abandon_tip_failed","Inspect the branch manually, then retry.");return await g(t,a),y(e,t,A,f,r),{node_id:e,branch:t.branch,tip_sha:A,worktree_path:t.path,branch_deleted:!1}}o(se,"abandonLocked");export{$e as abandonManagedWorktreeAsync,ve as autoDropCleanManagedWorktreeAsync,oe as concludeAbsentManagedWorktreeAsync,ge as createManagedWorktreeAsync,ye as rollbackManagedWorktreeAsync};

package/dist/core/worktree-quarantine.d.ts

@@ -0,0 +1,19 @@
+export interface QuarantinedWorktree {
+    node_id: string;
+    path: string;
+    branch: string;
+    repo_root: string;
+    /** Structured code for the refusal that quarantined this record. */
+    reason: string;
+    detail?: string;
+    /** Consecutive sweep passes that examined it without completing cleanup. */
+    attempts: number;
+    /** ISO timestamp of the most recent examination. */
+    last_attempt: string;
+    /** Bytes the checkout occupies, or null when the path is gone or unreadable. */
+    size_bytes: number | null;
+}
+/** Every managed worktree the sweep has flagged as needing attention, oldest
+ *  refusal first. Reads node records only — a checkout crtr did not create has
+ *  no node record and is never reported. */
+export declare function listQuarantinedManagedWorktrees(): Promise<QuarantinedWorktree[]>;

package/dist/core/worktree-quarantine.js

@@ -0,0 +1 @@
+var s=Object.defineProperty;var o=(a,t)=>s(a,"name",{value:t,configurable:!0});import{directorySizeBytes as r}from"./disk-usage.js";import{getNode as n,listNodes as p}from"./canvas/index.js";async function l(){const a=[];for(const t of p()){const e=n(t.node_id)?.managed_worktree;e?.sweep?.quarantined===!0&&a.push({node_id:t.node_id,path:e.path,branch:e.branch,repo_root:e.repo_root,reason:e.sweep.reason,...e.sweep.detail===void 0?{}:{detail:e.sweep.detail},attempts:e.sweep.attempts,last_attempt:e.sweep.last_attempt})}return a.sort((t,e)=>t.last_attempt.localeCompare(e.last_attempt)),Promise.all(a.map(async t=>({...t,size_bytes:await r(t.path)})))}o(l,"listQuarantinedManagedWorktrees");export{l as listQuarantinedManagedWorktrees};

package/dist/core/worktree-remove.d.ts

@@ -0,0 +1,15 @@
+import { type GitResult } from './git.js';
+export interface CheckoutRemoval {
+    result: GitResult;
+    /** The checkout's files, now in the trash; delete with `deleteTrashAsync` after releasing the lock. */
+    trash?: string;
+}
+/** `git worktree remove <path>` (no `--force`) that leaves the checkout's files
+ *  in the trash instead of deleting them. Call with the repository lock held,
+ *  from `cwd` outside the checkout. */
+export declare function removeWorktreeCheckoutAsync(cwd: string, path: string): Promise<CheckoutRemoval>;
+/** Delete `trash` (a removal's own entry, when given) plus any leftovers
+ *  beside `path` from an interrupted earlier delete. Runs `rm` as a child
+ *  process so the delete occupies neither the event loop nor libuv's
+ *  threadpool. Never throws. */
+export declare function deleteTrashAsync(path: string, trash?: string): Promise<void>;

package/dist/core/worktree-remove.js

@@ -0,0 +1 @@
+var w=Object.defineProperty;var u=(t,r)=>w(t,"name",{value:r,configurable:!0});import{execFile as k}from"node:child_process";import{randomUUID as g}from"node:crypto";import{existsSync as f,mkdirSync as v,readdirSync as b,renameSync as d}from"node:fs";import{basename as $,dirname as l,join as c}from"node:path";import{gitAsync as a}from"./git.js";function y(t){return c(l(t),".crtr-trash")}u(y,"trashDirFor");function m(t){return{status:1,stdout:"",stderr:t}}u(m,"refused");const D=600*1e3;async function T(t,r){const n=await a(["rev-parse","--absolute-git-dir"],r);if(n.status!==0)return{result:n};if(f(c(n.stdout.trim(),"locked")))return{result:m(`fatal: cannot remove a locked working tree: ${r}`)};if(f(c(n.stdout.trim(),"modules")))return{result:m(`fatal: working trees containing submodules cannot be moved or removed: ${r}`)};const o=await a(["status","--porcelain","--ignore-submodules=none"],r);if(o.status!==0)return{result:o};if(o.stdout.trim()!=="")return{result:m(`fatal: '${r}' contains modified or untracked files, use --force to delete it`)};const s=c(y(r),`${Date.now()}-${$(r)}-${g()}`);try{v(l(s),{recursive:!0}),d(r,s)}catch{return{result:await a(["worktree","remove",r],t)}}const e=await a(["worktree","remove",r],t);if(e.status===0)return{result:e,trash:s};try{d(s,r)}catch{}return{result:e}}u(T,"removeWorktreeCheckoutAsync");async function U(t,r){const n=y(t);let o=[];try{o=b(n)}catch{}const s=Date.now()-D,e=o.filter(i=>Number(i.split("-",1)[0])<s).map(i=>c(n,i));r!==void 0&&!e.includes(r)&&e.push(r),e.length!==0&&await new Promise(i=>{k("rm",["-rf","--",...e],()=>i())})}u(U,"deleteTrashAsync");export{U as deleteTrashAsync,T as removeWorktreeCheckoutAsync};

package/dist/core/worktree-sweep.d.ts

@@ -0,0 +1,60 @@
+import { type ManagedWorktree } from './canvas/index.js';
+export type SweepOutcome = 
+/** The checkout and branch are gone and the record is marked complete. */
+{
+    status: 'complete';
+    stash?: string;
+}
+/** Nothing to do: no record, already reconciled, or the node came back. */
+ | {
+    status: 'skipped';
+    reason: string;
+}
+/** A safety rule says this record must survive. Visible, retried, never fatal. */
+ | {
+    status: 'refused';
+    reason: string;
+    detail?: string;
+    unchanged?: true;
+}
+/** Git or the repository could not answer. Transient; retried. */
+ | {
+    status: 'failed';
+    reason: string;
+    detail?: string;
+};
+/** A record this sweep still owns: open, or closed without proven cleanup. An
+ *  abandoned record is deliberately out of scope — abandon already removed the
+ *  checkout and retains its branch for a person on purpose. */
+export declare function isReconcilable(wt: ManagedWorktree | null | undefined): boolean;
+/** Whether the sweep should examine this record on a pass starting at `now`. A
+ *  record with no recorded refusal is always due. */
+export declare function isDueForSweep(wt: ManagedWorktree, now: number): boolean;
+export interface ReconcileGuard {
+    /** Is the owning node STILL gone? Consulted synchronously immediately before
+     *  each Git mutation and before any metadata write — not once per pass.
+     *
+     *  The repository lock serializes worktree operations, NOT node lifecycle: a
+     *  revive can land in any of the awaits between the proof and the removal,
+     *  and it would then be running in the very checkout about to be deleted. So
+     *  every destructive step re-asks, and a false answer stops the pass where it
+     *  stands, leaving the record incomplete for a later pass to resume. The
+     *  implementation must not spawn a subprocess: this runs inside crtrd. */
+    stillEligible: () => boolean;
+}
+/** Dispose of one node's managed worktree, or explain why it must survive.
+ *
+ *  Ownership is proved from crouter's own node record, never from
+ *  `git worktree list`: a checkout the user or another tool created has no node
+ *  record and is never reachable from here. Under the repository lock the
+ *  recorded path is confirmed REGISTERED to the recorded branch — a path match
+ *  alone is not ownership — and removal is `git worktree remove <recorded
+ *  path>` without `--force`. `git worktree prune` is never run: it is
+ *  repo-wide and would touch administrative entries for worktrees crouter does
+ *  not own.
+ *
+ *  Effects are ordered checkout → branch → metadata so every interruption is
+ *  resumable: a crash before removal retries from pending; after removal but
+ *  before the branch delete, the branch is still an intact ref the next pass
+ *  finds; after both, the next pass observes both absent and marks complete. */
+export declare function reconcileManagedWorktree(nodeId: string, guard: ReconcileGuard, now?: number): Promise<SweepOutcome>;

package/dist/core/worktree-sweep.js

@@ -0,0 +1,6 @@
+var q=Object.defineProperty;var d=(e,t)=>q(e,"name",{value:t,configurable:!0});import{createHash as z}from"node:crypto";import{existsSync as y,realpathSync as K}from"node:fs";import{resolve as N}from"node:path";import{completeCleanup as U,getNode as v,recordSweepAttempt as C}from"./canvas/index.js";import{withExclusiveDirectoryLockAsync as Q}from"./exclusive-lock.js";import{gitAsync as c}from"./git.js";import{proveBranchContained as A,upstreamTip as V}from"./worktree-containment.js";import{parseStatusPorcelain as j,planLandIntoCheckout as G,refDeleteTransactionStdin as I}from"./worktree-landing.js";import{shellQuote as J}from"../shared/shell-quote.js";import{deleteTrashAsync as X,removeWorktreeCheckoutAsync as R}from"./worktree-remove.js";import{WORKTREE_LOCK_WAIT_MS as Y,checkoutPathForBranchInList as B,samePath as W,worktreeLockPathForCommonDir as Z}from"./worktree.js";const E=[2,5,15,30,60],ee=E.length;function D(e){return e==null||e.state==="abandoned"?!1:e.state==="open"||e.cleanup!=="complete"}d(D,"isReconcilable");function ve(e,t){const r=e.sweep?.next_attempt;if(r===void 0)return!0;const a=Date.parse(r);return Number.isNaN(a)||a<=t}d(ve,"isDueForSweep");async function m(e,t){const r=await c(["rev-parse","--verify","--quiet",t],e);return r.status===0?r.stdout.trim():null}d(m,"revParseRef");function h(e){return(e.stderr.trim()||e.stdout.trim()).trim()}d(h,"detailOf");async function L(e){const t=await c(["rev-parse","--git-common-dir"],e);if(t.status!==0)return null;try{return K(N(e,t.stdout.trim()))}catch{return null}}d(L,"commonGitDirAsync");async function te(e){for(const t of["rebase-merge","rebase-apply"]){const r=await c(["rev-parse","--git-path",t],e);if(r.status!==0)return null;if(y(N(e,r.stdout.trim())))return!0}return!1}d(te,"isRebaseInProgressAsync");function ae(e){for(const t of e.split(`
+`))if(t.startsWith("worktree "))return t.slice(9).trim();return null}d(ae,"mainWorktreePath");function re(e,t,r){let a=null;for(const s of e.split(`
+`))if(s.startsWith("worktree "))a=s.slice(9).trim();else if(a!==null&&s===`branch refs/heads/${r}`&&W(a,t))return a;return null}d(re,"registeredCheckoutPath");async function se(e){const t=y(e.path),r=t?e.path:e.repo_root,a=await m(r,`refs/heads/${e.base_ref}`),s=await V(r,e.base_ref),n=await m(r,`refs/heads/${e.branch}`);if(!t)return{base:a,upstream:s?.sha??null,branch:n,checkout:"absent"};const i=await c(["rev-parse","HEAD"],e.path),u=await c(["status","--porcelain"],e.path),o=i.status!==0||u.status!==0?null:z("sha256").update(`${i.stdout.trim()}
+${u.stdout}`).digest("hex");return{base:a,upstream:s?.sha??null,branch:n,checkout:o}}d(se,"observe");function ne(e,t){return e.checkout===null||t.checkout===null?!1:e.base===t.base&&e.upstream===t.upstream&&e.branch===t.branch&&e.checkout===t.checkout}d(ne,"sameObservation");function ie(e,t,r,a,s,n){if(r.status!=="refused"&&r.status!=="failed"||!n.stillEligible())return;const i=(t.sweep?.attempts??0)+1,u=E[Math.min(i,E.length)-1]??E[0],o=v(e)?.managed_worktree;o==null||!D(o)||C(e,{reason:r.reason,...r.detail===void 0?{}:{detail:r.detail},observed:a,attempts:i,lastAttemptAt:new Date(s).toISOString(),nextAttemptAt:new Date(s+u*6e4).toISOString(),quarantined:i>=ee})}d(ie,"recordUnfinished");async function oe(e,t,r,a,s){const n=await c(["status","--porcelain"],e);if(n.status!==0)return{ok:!1,detail:h(n)};const i=await c(["diff","--name-only",r,a],e);if(i.status!==0)return{ok:!1,detail:h(i)};const u=i.stdout.split(`
+`).map(p=>p.trim()).filter(p=>p!==""),o=G(j(n.stdout),u);if(o.kind==="refuse")return{ok:!1,detail:`untracked files in ${e} would be overwritten by the incoming commits: ${o.collisions.join(", ")}`};if(!s.stillEligible())return{ok:!1,detail:"node is no longer terminal",ineligible:!0};const l=d(async()=>{const p=await c(["merge","--ff-only",a],e);return p.status===0?{ok:!0}:{ok:!1,detail:h(p)}},"merge");if(o.kind==="direct")return l();const b=await m(e,"refs/stash"),g=await c(["stash","push","--message",`crtr landing ${t}`],e);if(g.status!==0)return{ok:!1,detail:h(g)};const f=await m(e,"refs/stash");if(f===null||f===b)return l();const k=`local changes from ${e} are retained in stash ${f}; recover them with \`git -C ${J(e)} stash apply ${f}\` and resolve any conflict.`,_=await l();return _.ok?(await c(["stash","apply",f],e)).status===0?(await M(e,f),{ok:!0}):(await c(["reset","--hard",a],e),{ok:!0,stash:`the shared base checkout was reset to landed commit ${a} because local changes conflicted with it. ${k}`}):(await c(["stash","apply",f],e)).status===0?(await M(e,f),_):{ok:!1,detail:`${_.detail}
+${k}`}}d(oe,"landIntoBaseCheckoutAsync");async function M(e,t){await m(e,"refs/stash")===t&&await c(["stash","drop"],e)}d(M,"dropStashIfStillTip");async function le(e,t,r){const a=await m(e.path,`refs/heads/${e.base_ref}`);if(a===null)return{ok:!1,detail:`local base branch '${e.base_ref}' does not resolve`};if(!r.stillEligible())return{ok:!1,detail:"node is no longer terminal",ineligible:!0};const s=await c(["rebase",a],e.path);if(s.status!==0)return await c(["rebase","--abort"],e.path),{ok:!1,detail:h(s)};const n=await m(e.path,"HEAD");if(n===null)return{ok:!1,detail:"could not read the rebased worktree tip"};if((await c(["merge-base","--is-ancestor",a,n],e.path)).status!==0)return{ok:!1,detail:`the rebased branch is not a fast-forward of '${e.base_ref}'`};const i=B(t,e.base_ref);if(i===null){if(!r.stillEligible())return{ok:!1,detail:"node is no longer terminal",ineligible:!0};const l=await c(["update-ref",`refs/heads/${e.base_ref}`,n,a],e.path);return l.status===0?{ok:!0,landedSha:n}:{ok:!1,detail:h(l)}}const u=await c(["rev-parse","HEAD"],i);if(u.status!==0||u.stdout.trim()!==a)return{ok:!1,detail:`base checkout ${i} is not at ${a}`};const o=await oe(i,e.branch,a,n,r);return o.ok?{ok:!0,landedSha:n,...o.stash===void 0?{}:{stash:o.stash}}:o}d(le,"finishBlockedLand");const $={status:"skipped",reason:"node_no_longer_terminal"};async function Ee(e,t,r=Date.now()){const a=v(e)?.managed_worktree;if(!D(a)||a==null)return{status:"skipped",reason:"already_reconciled"};const s=y(a.path)?a.path:a.repo_root;if(!y(s))return S(e,a,{status:"refused",reason:"repo_unavailable",detail:`neither the recorded checkout nor repository root exists, so ${a.branch} cannot be proved absent`},{base:null,upstream:null,branch:null,checkout:null},r,t);const n=await L(s);if(n===null)return S(e,a,{status:"failed",reason:"git_dir_unreadable",detail:`could not resolve the git common dir from ${s}`},{base:null,upstream:null,branch:null,checkout:null},r,t);let i={base:null,upstream:null,branch:null,checkout:null},u;const o=[];try{u=await Q(Z(n),async()=>{if(!t.stillEligible())return $;const l=v(e)?.managed_worktree;return!D(l)||l==null?{status:"skipped",reason:"already_reconciled"}:(i=await se(l),l.sweep!==void 0&&ne(l.sweep.observed,i)?{status:"refused",reason:l.sweep.reason,...l.sweep.detail===void 0?{}:{detail:l.sweep.detail},unchanged:!0}:y(l.path)?await ce(e,l,t,o):await ue(e,l,i,t))},{timeoutMs:Y,timeoutError:d(()=>new Error(`timed out waiting for the managed-worktree lock on ${n}`),"timeoutError")})}catch(l){u={status:"failed",reason:"lock_unavailable",detail:l instanceof Error?l.message:String(l)}}return await X(a.path,o[0]),S(e,a,u,i,r,t)}d(Ee,"reconcileManagedWorktree");function S(e,t,r,a,s,n){return ie(e,t,r,a,s,n),r}d(S,"finish");function x(e,t,r){if(!r.stillEligible())return $;const a=v(e)?.managed_worktree;return a==null||a.path!==t.path||a.branch!==t.branch?{status:"skipped",reason:"record_changed"}:(U(e),{status:"complete"})}d(x,"persistComplete");async function ue(e,t,r,a){const s=t.repo_root;if(r.branch===null){const o=await c(["show-ref","--verify","--quiet",`refs/heads/${t.branch}`],s);return o.status!==1?{status:"failed",reason:"branch_inspection_failed",detail:h(o)}:x(e,t,a)}const n=await c(["worktree","list","--porcelain"],s);if(n.status!==0)return{status:"failed",reason:"worktree_list_failed",detail:h(n)};const i=B(n.stdout,t.branch);if(i!==null)return{status:"refused",reason:"branch_checked_out_elsewhere",detail:`${t.branch} is checked out at ${i}`};const u=await A(s,t,r.branch);return u===null?{status:"refused",reason:"unlanded_work",detail:`${t.branch} carries content no base or upstream ref contains; its checkout is already gone, so the branch is the only copy`}:F(e,t,s,r.branch,u,a)}d(ue,"concludeAbsentCheckout");async function ce(e,t,r,a){const s=await c(["worktree","list","--porcelain"],t.path);if(s.status!==0)return{status:"failed",reason:"worktree_list_failed",detail:h(s)};const n=t.disposal,i=n?.observed_branch??t.branch,u=re(s.stdout,t.path,i);if(u===null)return{status:"refused",reason:"not_registered",detail:`${t.path} is not registered to refs/heads/${i}; crtr will not act on a path it cannot prove it owns`};const o=ae(s.stdout);if(o===null||W(o,u)||!y(o))return{status:"refused",reason:"repo_unavailable",detail:`the repository's main checkout is unavailable, so ${t.path} cannot be removed from outside itself`};const l=await te(t.path);if(l===null)return{status:"failed",reason:"git_path_failed",detail:`could not inspect in-progress operations in ${t.path}`};if(l)return{status:"refused",reason:"rebase_in_progress",detail:`${t.path} is mid-rebase`};const b=await c(["rev-parse","--abbrev-ref","HEAD"],t.path);if(b.status!==0)return{status:"failed",reason:"branch_check_failed",detail:h(b)};if(b.stdout.trim()!==i)return{status:"refused",reason:"wrong_branch",detail:`expected ${i}, found ${b.stdout.trim()==="HEAD"?"detached HEAD":b.stdout.trim()}`};const g=await c(["status","--porcelain"],t.path);if(g.status!==0)return{status:"failed",reason:"status_failed",detail:h(g)};if(g.stdout.trim()!=="")return{status:"refused",reason:"dirty_worktree",detail:`${t.path} has uncommitted changes`};let f=await m(t.path,"HEAD");if(f===null)return{status:"failed",reason:"head_unreadable",detail:`could not read HEAD in ${t.path}`};if(n!==void 0){if(await L(t.path)!==n.common_dir||f!==n.observed_sha)return{status:"refused",reason:"disposal_authorization_stale",detail:`${t.path} changed since \`close\` authorized its disposal; rerun \`crtr node worktree close\` from that node to re-authorize, or ask the user with \`crtr human send\``};if(!r.stillEligible())return $;const{result:H,trash:O}=await R(o,u);return O!==void 0&&a.push(O),H.status!==0?{status:"refused",reason:"worktree_remove_failed",detail:h(H)}:x(e,t,r)}let k=await A(t.path,t,f),_;if(k===null&&t.land_intent!==void 0){const w=await le(t,s.stdout,r);if(!w.ok)return w.ineligible===!0?$:{status:"refused",reason:"land_blocked",detail:w.detail};f=w.landedSha,_=w.stash,k=await A(t.path,t,f)}if(k===null)return{status:"refused",reason:"unlanded_work",detail:`${t.branch} carries commits its base does not contain, and this node never asked to land them`};if(!r.stillEligible())return $;const{result:p,trash:P}=await R(o,u);if(P!==void 0&&a.push(P),p.status!==0)return{status:"refused",reason:"worktree_remove_failed",detail:h(p)};const T=await F(e,t,o,f,k,r);return T.status==="complete"&&_!==void 0?{status:"complete",stash:_}:T}d(ce,"reconcilePresentCheckout");async function F(e,t,r,a,s,n){if(!n.stillEligible())return $;const i=I(t.branch,a,s.containingRef,s.containingSha),u=await c(["update-ref","--stdin"],r,i);return u.status!==0?{status:"refused",reason:"branch_delete_failed",detail:h(u)}:x(e,t,n)}d(F,"deleteBranchAndComplete");export{ve as isDueForSweep,D as isReconcilable,Ee as reconcileManagedWorktree};

package/dist/core/worktree.d.ts

@@ -0,0 +1,120 @@
+import { type NodeMeta, type ManagedWorktree } from './canvas/index.js';
+export interface WorktreeCommandResult {
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+}
+export declare class WorktreeError extends Error {
+    code: string;
+    next: string;
+    detail?: string;
+    constructor(code: string, message: string, next: string, detail?: string);
+}
+export declare function managedWorktreesRoot(): string;
+export declare function managedWorktreePath(nodeId: string): string;
+export declare function hasOpenManagedWorktree(node: NodeMeta | null | undefined): boolean;
+export declare function openManagedWorktreeForNode(nodeId: string): ManagedWorktree | null;
+export declare function isManagedWorktreeBase(repoRoot: string): boolean;
+/** Shared parse for a `git worktree list --porcelain` blob already in hand —
+ *  callers that must not throw on a read failure (an absent-path proof that
+ *  needs to fail closed rather than error) call `gitSync` themselves and pass
+ *  the output here instead of going through `checkoutPathForBranch`. */
+export declare function checkoutPathForBranchInList(porcelain: string, branch: string): string | null;
+/** Are these two spellings the same directory?
+ *
+ *  Git canonicalizes every path it prints in `worktree list --porcelain`, while
+ *  a recorded managed-worktree path preserves the spelling of `CRTR_HOME`. When
+ *  the canvas home is reached through a symlink (macOS's `/var` → `/private/var`
+ *  is the everyday case) the two forms name one directory but differ as
+ *  strings, so a raw `===` reads a checkout crtr created as unowned. Resolution
+ *  failures fall back to `resolve`, which is the pre-canonical comparison — no
+ *  worse than the string compare it replaces. */
+export declare function samePath(a: string, b: string): boolean;
+export declare const WORKTREE_LOCK_WAIT_MS = 30000;
+/** The lock directory naming one repository's common Git dir. Every process
+ *  that mutates a managed worktree — the synchronous commands here and the
+ *  daemon's asynchronous sweep — derives its lock path through this function,
+ *  so the two locking styles contend for the SAME name. */
+export declare function worktreeLockPathForCommonDir(commonDir: string): string;
+export declare function rollbackManagedWorktree(wt: ManagedWorktree): void;
+export declare function createManagedWorktree(cwd: string, nodeId: string, baseRef?: string): ManagedWorktree;
+export declare function isRebaseInProgress(cwd: string): boolean;
+export interface CloseManagedWorktreeResult {
+    node_id: string;
+    branch: string;
+    worktree_path: string;
+    landed_sha: string;
+    /** Always false for a live caller: cleanup is deliberately pending until
+     * the caller exits and the reported manual command can safely remove it. */
+    worktree_removed: boolean;
+    worktree_remove_error?: string;
+    /** Always false while the pending-cleanup checkout has this branch checked out. */
+    branch_deleted: boolean;
+    branch_delete_error?: string;
+    /** Present ONLY when landing had to stash local changes in the base checkout
+     *  and re-applying them conflicted: names the preserved stash and how to
+     *  re-apply it. Its absence means nothing local was left over. */
+    base_checkout_stash?: string;
+}
+/** The ONE authoritative closed-worktree state transition, shared by every
+ * closing path (explicit `closeManagedWorktreeLocked` land, the clean
+ * `autoDropCleanManagedWorktreeLocked` push-final drop, and the daemon sweep's
+ * `reconcileManagedWorktree`): persist
+ * `managed_worktree.state: 'closed'`, name its cleanup state, and repoint the
+ * node's launch `cwd` to the durable base checkout. The caller broker stays
+ * alive and is Pi's sole transcript writer, so its session header cannot be
+ * safely rewritten here; clear the session coordinates and let the later
+ * revive launch fresh instead. Both closing paths MUST go through this helper
+ * instead of hand-rolling the `updateNode` call, so neither can drift out of
+ * sync. */
+export declare function persistClosedWorktreeState(nodeId: string, wt: ManagedWorktree, cleanup?: 'pending' | 'complete'): void;
+export declare function closeManagedWorktree(nodeId: string): CloseManagedWorktreeResult;
+export interface AbandonManagedWorktreeResult {
+    node_id: string;
+    branch: string;
+    tip_sha: string;
+    worktree_path: string;
+    branch_deleted: boolean;
+}
+/** Recovery guidance for a vanished checkout whose refs do not prove that its
+ * work is delivered. This deliberately never recommends `worktree close`:
+ * that command cannot operate on the absent checkout. */
+export declare function missingWorktreeRecoveryHint(wt: ManagedWorktree): string;
+interface CleanEmptyProof {
+    /** The branch's HEAD SHA at the moment this was proven clean and contained
+     * in the current base. */
+    branchSha: string;
+    /** The current base tip, retained for race diagnostics. */
+    baseSha: string;
+}
+/** Fix B's shared "nothing to land" test — the SAME clean-worktree definition
+ *  `close`'s own dirty check now naturally satisfies once `.git/info/exclude`
+ *  hides crtr's own `.crouter/config.json`/`state.json` bookkeeping (Fix A),
+ *  plus one more requirement close doesn't need: the branch tip must already
+ *  be a git-ancestor of (or equal to) the CURRENT tip of its recorded base
+ *  branch — i.e. landing it would be a pure no-op. Any ambiguity (missing
+ *  path, mid-rebase, wrong branch, an unresolvable base, or a real ancestry
+ *  divergence) returns null. A missing base is the one exception: equality
+ *  between the live HEAD and recorded creation SHA proves no work was added.
+ *  This function only ever proves a no-op land from live Git state, never on
+ *  a heuristic guess, so real unlanded work always falls through to the explicit-close guard. The locked
+ *  path re-checks this predicate before recording deferred cleanup; production
+ *  code must always go through `autoDropCleanManagedWorktree`. */
+export declare function proveCleanEmptyManagedWorktree(wt: ManagedWorktree): CleanEmptyProof | null;
+export interface AutoDroppedWorktree {
+    node_id: string;
+    branch: string;
+    worktree_path: string;
+    worktree_removed: boolean;
+    worktree_remove_error?: string;
+    branch_deleted: boolean;
+    branch_delete_error?: string;
+}
+/** Re-check a clean auto-drop before closing its record. `push final` runs
+ * inside the owner broker, so it has the same destructive-cwd boundary as
+ * explicit close: removal and branch deletion are deferred until that owner
+ * has exited. */
+export declare function autoDropCleanManagedWorktreeLocked(nodeId: string, wt: ManagedWorktree, proof: CleanEmptyProof): AutoDroppedWorktree | null;
+export declare function branchIsPushedAtCurrentTip(wt: ManagedWorktree): Promise<boolean>;
+export declare function autoDropCleanManagedWorktree(nodeId: string): AutoDroppedWorktree | null;
+export {};

package/dist/core/worktree.js

@@ -0,0 +1,18 @@
+var J=Object.defineProperty;var a=(e,r)=>J(e,"name",{value:r,configurable:!0});import{existsSync as k,mkdirSync as H,readFileSync as V,realpathSync as N,rmSync as Y,writeFileSync as Z}from"node:fs";import{createHash as ee}from"node:crypto";import{dirname as te,isAbsolute as re,join as ne,relative as oe,resolve as C,sep as se}from"node:path";import{gitAsync as ae,gitSync as i}from"./git.js";import{crtrHome as O}from"./canvas/paths.js";import{closeWorktreeAndRepoint as ie,getNode as v,recordLandIntent as ce}from"./canvas/index.js";import{CONFIG_FILE as he,CRTR_DIR_NAME as F,STATE_FILE as ue}from"../types.js";import{withExclusiveDirectoryLock as le}from"./exclusive-lock.js";import{parseStatusPorcelain as de,planLandIntoCheckout as fe,refDeleteTransactionStdin as pe}from"./worktree-landing.js";import{shellQuote as w}from"../shared/shell-quote.js";class f extends Error{static{a(this,"WorktreeError")}code;next;detail;constructor(r,t,n,o){super(t),this.name="WorktreeError",this.code=r,this.next=n,this.detail=o}}function _(e,r,t,n){const o=i(r,e);if(o.status!==0){const s=(o.stderr.trim()||o.stdout.trim()).trim();throw new f(t,`git ${r.join(" ")} failed`,n,s)}return o.stdout.trim()}a(_,"runGit");function I(){return`${O()}/worktrees`}a(I,"managedWorktreesRoot");function me(e){return`${I()}/${e}`}a(me,"managedWorktreePath");function Ke(e){return e?.managed_worktree?.state==="open"}a(Ke,"hasOpenManagedWorktree");function x(e){const t=v(e)?.managed_worktree;return t?.state==="open"?t:null}a(x,"openManagedWorktreeForNode");function be(e){const r=i(["rev-parse","--show-toplevel"],e);if(r.status!==0){const t=(r.stderr.trim()||r.stdout.trim()).trim();throw new f("not_git_repo",`cwd ${e} is not a git repository`,"Pass --cwd <real repo> pointing inside a git repository.",t)}return r.stdout.trim()}a(be,"repoRootFor");function ke(e){const r=oe(S(I()),S(e));return r!==""&&r!==".."&&!r.startsWith(`..${se}`)&&!re(r)}a(ke,"isManagedWorktreeBase");function _e(e,r){const t=`refs/heads/${r}`,n=i(["show-ref","--verify","--quiet",t],e);if(n.status===0)return!0;if(n.status===1&&n.executionFailed!==!0)return!1;const o=n.stderr.trim()||"<empty>",s=n.processError===void 0?"":`
+process error: ${n.processError}`;throw new f("recorded_branch_inspection_failed",`could not inspect recorded branch '${r}' (git show-ref exited with status ${n.status})`,"Inspect the repository and its Git metadata, then retry.",`status: ${n.status}
+stderr: ${o}${s}`)}a(_e,"recordedBranchExists");function A(e,r){const t=`refs/heads/${r}`,n=i(["show-ref","--verify","--quiet",t],e);if(n.status===1&&n.executionFailed!==!0)throw new f("missing_base_branch",`managed worktree base '${r}' does not name an existing local branch`,"The base must be a local branch that landing can fast-forward \u2014 freshen your local branch from origin first (rebase-not-merge), then base on it.");if(n.status!==0){const o=n.stderr.trim()||"<empty>",s=n.processError===void 0?"":`
+process error: ${n.processError}`;throw new f("base_branch_inspection_failed",`could not inspect local base branch '${r}' (git show-ref exited with status ${n.status})`,"Inspect the repository and its Git metadata, then retry.",`status: ${n.status}
+stderr: ${o}${s}`)}return _(e,["rev-parse","--verify",t],"base_branch_resolve_failed","Inspect the local base branch, then retry.")}a(A,"resolveLandableBase");function ge(e,r){const t=_(e,["worktree","list","--porcelain"],"worktree_list_failed","Inspect the repository worktrees manually, then retry.");return q(t,r)}a(ge,"checkoutPathForBranch");function q(e,r){let t=null;for(const n of e.split(`
+`))if(n.startsWith("worktree "))t=n.slice(9).trim();else if(n===`branch refs/heads/${r}`)return t;return null}a(q,"checkoutPathForBranchInList");function we(e,r){return e===r||S(e)===S(r)}a(we,"samePath");function S(e){try{return N.native(e)}catch{return C(e)}}a(S,"canonicalPath");const $e=3e4;function ye(e){const r=`${O()}/worktree-locks`;return H(r,{recursive:!0}),`${r}/${ee("sha256").update(e).digest("hex")}`}a(ye,"worktreeLockPathForCommonDir");function R(e){const r=_(e,["rev-parse","--git-common-dir"],"git_common_dir_failed","Inspect the repository git metadata, then retry.");return N(C(e,r))}a(R,"commonGitDir");function E(e,r){const t=R(e);return le(ye(t),r,{timeoutMs:$e,timeoutError:a(()=>new f("worktree_lock_timeout",`timed out waiting to create a managed worktree in ${t}`,"Wait for the other managed-worktree operation to finish, then retry."),"timeoutError")})}a(E,"withRepositoryWorktreeLock");function D(e,r,t){const n=i(["worktree","list","--porcelain"],e);if(n.status!==0)return null;let o=null;for(const s of n.stdout.split(`
+`))if(s.startsWith("worktree "))o=s.slice(9).trim();else if(o!==null&&we(o,r)&&s===`branch refs/heads/${t}`)return!0;return!1}a(D,"registeredWorktree");function ve(e,r,t){const n=[],o=`refs/heads/${r}`,s=i(["rev-parse","--verify","--quiet",o],e);s.status===0&&n.push({ref:o,sha:s.stdout.trim()});const u=i(["rev-parse","--symbolic-full-name","--verify",`${r}@{upstream}`],e),h=u.status===0&&u.stdout.trim().startsWith("refs/")?u.stdout.trim():`refs/remotes/origin/${r}`,m=i(["rev-parse","--verify","--quiet",h],e);if(m.status===0&&n.push({ref:h,sha:m.stdout.trim()}),n.length===0)return null;for(const d of n)if(i(["merge-base","--is-ancestor",t,d.sha],e).status===0)return{containingRef:d.ref,containingSha:d.sha};for(const d of n){const l=i(["cherry",d.sha,t],e);if(l.status!==0)continue;if(l.stdout.split(`
+`).map(c=>c.trim()).filter(c=>c!=="").every(c=>c.startsWith("-")))return{containingRef:d.ref,containingSha:d.sha}}for(const d of n){const l=i(["rev-parse","--verify",`${d.sha}^{tree}`],e);if(l.status!==0)continue;const b=i(["merge-tree","--write-tree",d.sha,t],e);if(b.status===0&&b.stdout.split(`
+`)[0]?.trim()===l.stdout.trim())return{containingRef:d.ref,containingSha:d.sha}}return null}a(ve,"proveBranchContained");function G(e,r){const t=i(["rev-parse","--verify",`refs/heads/${e.branch}`],e.repo_root);if(t.status!==0||t.stdout.trim()!==e.base_sha)return;const n=D(e.repo_root,e.path,e.branch);if(n!==null){if(n){if(i(["worktree","remove","--force",e.path],e.repo_root).status!==0||D(e.repo_root,e.path,e.branch)!==!1)return}else if(r&&k(e.path))try{Y(e.path,{recursive:!0,force:!0})}catch{return}try{i(["update-ref","-d",`refs/heads/${e.branch}`,e.base_sha],e.repo_root)}catch{}}}a(G,"rollbackManagedWorktreeLocked");function Ue(e){E(e.repo_root,()=>G(e,!1))}a(Ue,"rollbackManagedWorktree");const xe="# crtr: exclude crtr's own untracked project-scope bookkeeping (auto-added at managed-worktree creation)",Se=[`/${F}/${he}`,`/${F}/${ue}`];function Ee(e){try{const r=ne(R(e),"info","exclude");H(te(r),{recursive:!0});let t="";try{t=V(r,"utf8")}catch{}const n=new Set(t.split(`
+`).map(h=>h.trim())),o=Se.filter(h=>!n.has(h));if(o.length===0)return;const u=(t.length>0&&!t.endsWith(`
+`)?`
+`:"")+xe+`
+`+o.join(`
+`)+`
+`;Z(r,t+u)}catch{}}a(Ee,"seedManagedWorktreeExclude");function Xe(e,r,t="main"){const n=be(e);if(ke(n))throw new f("managed_worktree_base",`cwd ${n} is a managed worktree and cannot be used as a managed worktree base`,"Pass `--cwd` pointing at the repository\u2019s primary checkout and keep `--worktree` set to the desired existing local base branch, including the parent branch.");return E(n,()=>{const o=A(n,t),s=me(r),u=`crtr/${r}`;if(k(s))throw new f("worktree_path_exists",`managed worktree path already exists: ${s}`,"Remove the stale path or choose a fresh node id.");if(i(["show-ref","--verify","--quiet",`refs/heads/${u}`],n).status===0)throw new f("worktree_branch_exists",`managed worktree branch already exists: ${u}`,"Remove the stale branch or choose a fresh node id.");const h={state:"open",path:s,branch:u,repo_root:n,base_ref:t,base_sha:o,created:new Date().toISOString()};_(n,["branch",u,o],"worktree_branch_create_failed","Inspect the git error, fix the repository/worktree state, then retry spawning with --worktree.");try{return _(n,["worktree","add",s,u],"worktree_add_failed","Inspect the git error, fix the repository/worktree state, then retry spawning with --worktree."),Ee(n),h}catch(m){throw G(h,!0),m}})}a(Xe,"createManagedWorktree");function De(e){return _(e,["status","--porcelain"],"status_failed","Inspect the worktree manually, then retry.")}a(De,"statusPorcelain");function B(e){return _(e,["rev-parse","--abbrev-ref","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry.")}a(B,"currentBranch");function j(e,r){return _(e,["rev-parse","--git-path",r],"git_path_failed","Inspect the worktree manually, then retry.")}a(j,"gitPath");function M(e){return k(j(e,"rebase-merge"))||k(j(e,"rebase-apply"))}a(M,"isRebaseInProgress");function y(e,r,t="pending"){const n=v(e);ie(e,{cwd:r.repo_root,cleanup:t,closedAt:new Date().toISOString(),unbindSession:n?.pi_session_id!=null||n?.pi_session_file!=null})}a(y,"persistClosedWorktreeState");function We(e,r){const t=v(e)?.managed_worktree;t==null||t.state!=="open"||ce(e,{at:new Date().toISOString(),blocked:r})}a(We,"recordBlockedLandIntent");function Ae(e,r,t,n){const o=i(["status","--porcelain"],e);if(o.status!==0)return{ok:!1,detail:(o.stderr.trim()||o.stdout.trim()).trim()};const s=i(["diff","--name-only",t,n],e);if(s.status!==0)return{ok:!1,detail:(s.stderr.trim()||s.stdout.trim()).trim()};const u=s.stdout.split(`
+`).map(g=>g.trim()).filter(g=>g!==""),h=fe(de(o.stdout),u);if(h.kind==="refuse")return{ok:!1,detail:`untracked files in ${e} would be overwritten by the incoming commits: ${h.collisions.join(", ")}`};const m=a(()=>{const g=i(["merge","--ff-only",n],e);return g.status===0?{ok:!0}:{ok:!1,detail:(g.stderr.trim()||g.stdout.trim()).trim()}},"merge");if(h.kind==="direct")return m();const d=i(["rev-parse","--verify","--quiet","refs/stash"],e),l=d.status===0?d.stdout.trim():null,b=i(["stash","push","--message",`crtr landing ${r}`],e);if(b.status!==0)return{ok:!1,detail:(b.stderr.trim()||b.stdout.trim()).trim()};const c=i(["rev-parse","--verify","--quiet","refs/stash"],e),p=c.status===0?c.stdout.trim():null;if(p===null||p===l)return m();const $=`local changes from ${e} are retained in stash ${p}; recover them with \`git -C ${w(e)} stash apply ${p}\` and resolve any conflict.`,W=m();return W.ok?i(["stash","apply",p],e).status===0?(K(e,p),{ok:!0}):(i(["reset","--hard",n],e),{ok:!0,stash:`the shared base checkout was reset to landed commit ${n} because local changes conflicted with it. ${$}`}):i(["stash","apply",p],e).status===0?(K(e,p),W):{ok:!1,detail:`${W.detail}
+${$}`}}a(Ae,"landIntoBaseCheckout");function K(e,r){const t=i(["rev-parse","--verify","--quiet","refs/stash"],e);t.status===0&&t.stdout.trim()===r&&i(["stash","drop"],e)}a(K,"dropStashIfStillTip");function T(e){const r=`git -C ${w(e.repo_root)} worktree remove ${w(e.path)}`;return{worktree_removed:!1,worktree_remove_error:`cleanup pending: the caller checkout at ${e.path} remains intact. After its node exits, run \`${r}\` after confirming it is safe to delete.`,branch_deleted:!1,branch_delete_error:`cleanup pending: local branch ${e.branch} remains checked out at ${e.path}; delete it only after that checkout is removed and its landed commit is still contained in ${e.base_ref}.`}}a(T,"deferredCleanupResult");function Re(e,r,t){if(D(r.repo_root,r.path,t)!==!0)throw new f("wrong_branch",`managed worktree's recorded branch ${r.branch} no longer exists, and its checkout at ${r.path} is not registered to ${t} either`,`Inspect ${r.path} and its git worktree registration, then ask the user with \`crtr human send\` if you are unsure how to proceed.`);const n=_(r.path,["rev-parse","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry.");if(ve(r.path,r.base_ref,n)===null)throw new f("branch_moved_unlanded",`managed worktree's recorded branch ${r.branch} no longer exists; its checkout is now on ${t} at ${n}, which carries content local base branch '${r.base_ref}' does not yet contain`,`Land or push ${t} through its own workflow (merge its PR, or fast-forward '${r.base_ref}' to include it) before closing, or ask the user with \`crtr human send\` if you are unsure how ${t} should be delivered.`);const s=R(r.repo_root),u=D(r.repo_root,r.path,t)===!0,h=B(r.path)===t,m=_(r.path,["rev-parse","HEAD"],"branch_check_failed","Inspect the worktree manually, then retry.")===n;if(!u||!h||!m)throw new f("wrong_branch",`managed worktree at ${r.path} changed while closing`,`Inspect ${r.path}, then rerun \`crtr node worktree close\`.`);const d={observed_branch:t,observed_sha:n,common_dir:s,authorized:new Date().toISOString()};y(e,{...r,disposal:d},"pending");const l=`git -C ${w(r.repo_root)} worktree remove ${w(r.path)}`;return{node_id:e,branch:t,worktree_path:r.path,landed_sha:n,worktree_removed:!1,worktree_remove_error:`cleanup pending: the caller checkout at ${r.path} remains intact. After its node exits, run \`${l}\` after confirming it is safe to delete.`,branch_deleted:!1,branch_delete_error:`${t} is not a crtr-managed branch and will never be deleted automatically; it is preserved once the checkout above is removed.`}}a(Re,"closeBranchMovedWorktree");function Me(e,r){const t=v(e)?.managed_worktree;if(t==null)return{message:`node ${e} has no managed worktree`,next:`Nothing to ${r} for this node.`};if(t.state==="abandoned"){const n=t.abandoned?.branch??t.branch;return{message:`node ${e}'s managed worktree was already abandoned`,next:`Nothing to ${r} for this node; its work was retained on branch ${n}.`}}return t.state==="closed"?t.cleanup==="complete"?{message:`node ${e}'s managed worktree is already closed and its cleanup is complete`,next:`Nothing to ${r} for this node.`}:{message:`node ${e}'s managed worktree is already closed; this is not lost ownership \u2014 its checkout at ${t.path} is scheduled for automatic cleanup once that is safe`,next:`Nothing to ${r} for this node. The daemon sweep finishes removing ${t.path} on its own; inspect it directly only if it still needs manual attention.`}:{message:`node ${e} has no open managed worktree`,next:`Nothing to ${r} for this node.`}}a(Me,"noManagedWorktreeMessage");function U(e){if(v(e)===null)throw new f("unknown_node",`unknown node: ${e}`,"Run this from a live node, or pass a real node id once that command supports it.");const t=x(e);if(t===null){const{message:c,next:p}=Me(e,"close");throw new f("no_managed_worktree",c,p)}if(!k(t.path)){const c=P(t);if(c===null)throw new f("worktree_missing",`managed worktree path is missing: ${t.path}`,X(t));if(z(e,t,c)===null)throw new f("worktree_missing",`managed worktree path is missing: ${t.path}`,X(t));return{node_id:e,branch:t.branch,worktree_path:t.path,landed_sha:c.branchSha??t.base_sha,worktree_removed:!0,branch_deleted:!0}}if(M(t.path))throw new f("rebase_in_progress","this managed worktree is mid-rebase",`Resolve conflicts in ${t.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree close\`.`);if(De(t.path)!=="")throw new f("dirty_worktree","managed worktree has uncommitted changes",`Commit the work in ${t.path} (or ask the user with \`crtr human send\` if you do not know whether to keep it), then rerun \`crtr node worktree close\`.`);const o=B(t.path);if(o!==t.branch){const c=o==="HEAD"?"detached HEAD":o,p=_e(t.path,t.branch);if(p||o==="HEAD")throw new f("wrong_branch",`managed worktree is not on its recorded branch (expected ${t.branch}, found ${c})`,p?`Check out ${t.branch} in ${t.path} before closing, or ask the user with \`crtr human send\` if you are unsure why it changed, then rerun \`crtr node worktree close\`.`:`The recorded branch ${t.branch} no longer exists, and ${t.path} is in detached HEAD, so there is no branch to preserve. Check out or create a branch there before closing, or ask the user with \`crtr human send\` if you are unsure how to proceed.`);return Re(e,t,o)}let s;try{s=A(t.path,t.base_ref)}catch(c){const p=_(t.path,["rev-parse","HEAD"],"landed_sha_failed","Inspect the worktree checkout manually, then rerun `crtr node worktree close`.");if(!(c instanceof f)||c.code!=="missing_base_branch"||p!==t.base_sha)throw c;return y(e,t,"pending"),{node_id:e,branch:t.branch,worktree_path:t.path,landed_sha:t.base_sha,...T(t)}}const u=i(["rebase",s],t.path);if(u.status!==0){const c=(u.stderr.trim()||u.stdout.trim()).trim();throw new f("rebase_failed",`rebase onto local base branch '${t.base_ref}' did not complete`,`Resolve conflicts in ${t.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree close\`. If the blocker is not mechanical, ask the user with \`crtr human send\`.`,c)}const h=_(t.path,["rev-parse","HEAD"],"landed_sha_failed","Inspect the worktree checkout manually, then rerun `crtr node worktree close`."),m=a((c,p,$)=>(We(e,c),new f("land_base_failed",c,p,$)),"blocked"),d=i(["merge-base","--is-ancestor",s,h],t.path);if(d.status!==0)throw m(`rebased worktree is not a fast-forward of local base branch '${t.base_ref}'`,"Ask the user with `crtr human send` how to land this managed worktree.",(d.stderr.trim()||d.stdout.trim()).trim());const l=ge(t.path,t.base_ref);if(l!==null){const c=i(["rev-parse","HEAD"],l),p=c.stdout.trim();if(c.status!==0||p!==s){const $=c.status!==0?(c.stderr.trim()||p).trim():`expected ${s}, found ${p}`;throw m(`local base branch '${t.base_ref}' changed while this worktree was closing`,`Reconcile the base checkout at ${l}, then rerun \`crtr node worktree close\`. If you are unsure, ask the user with \`crtr human send\`.`,$)}}let b;if(l!==null){const c=Ae(l,t.branch,s,h);if(!c.ok)throw m(`could not fast-forward local base branch '${t.base_ref}' to this worktree`,`Local base branch '${t.base_ref}' is checked out at ${l} in a state that blocks a fast-forward. Reconcile it there, then rerun \`crtr node worktree close\`. If you are unsure, ask the user with \`crtr human send\`.`,c.detail);b=c.stash}else{const c=i(["update-ref",`refs/heads/${t.base_ref}`,h,s],t.path);if(c.status!==0)throw m(`could not fast-forward local base branch '${t.base_ref}' to this worktree`,"Ask the user with `crtr human send` how to land this managed worktree.",(c.stderr.trim()||c.stdout.trim()).trim())}return y(e,t,"pending"),{node_id:e,branch:t.branch,worktree_path:t.path,landed_sha:h,...T(t),...b===void 0?{}:{base_checkout_stash:b}}}a(U,"closeManagedWorktreeLocked");function ze(e){const r=x(e);return r===null?U(e):E(k(r.path)?r.path:r.repo_root,()=>U(e))}a(ze,"closeManagedWorktree");function Te(e,r,t,n){const o=pe(e.branch,r,t,n),s=i(["update-ref","--stdin"],e.repo_root,o),u=s.status===0;if(u)return{branchDeleted:u};const h=(s.stderr.trim()||s.stdout.trim()).trim();return{branchDeleted:u,branchDeleteError:`local branch ${e.branch} could not be deleted automatically (${h}); run \`git -C ${w(e.repo_root)} branch -D ${w(e.branch)}\` after confirming it is merged.`}}a(Te,"bestEffortDeleteBranchWithContainmentProof");function P(e){if(e.state!=="open"||k(e.path))return null;const r=`refs/heads/${e.branch}`,t=i(["show-ref","--verify","--quiet",r],e.repo_root);if(t.status===1)return{branchSha:null};if(t.status!==0)return null;const n=i(["rev-parse","--verify",r],e.repo_root);if(n.status!==0)return null;const o=n.stdout.trim(),s=i(["worktree","list","--porcelain"],e.repo_root);if(s.status!==0||q(s.stdout,e.branch)!==null)return null;const u=[],h=`refs/heads/${e.base_ref}`,m=i(["show-ref","--verify","--quiet",h],e.repo_root);if(m.status===0){const l=i(["rev-parse","--verify",h],e.repo_root);if(l.status!==0)return null;u.push({ref:h,sha:l.stdout.trim()})}else if(m.status!==1)return null;const d=i(["rev-parse","--symbolic-full-name","--verify",`${e.base_ref}@{upstream}`],e.repo_root);if(d.status===0){const l=d.stdout.trim(),b=i(["rev-parse","--verify",l],e.repo_root);l.startsWith("refs/")&&b.status===0&&u.push({ref:l,sha:b.stdout.trim()})}else{const l=`refs/remotes/origin/${e.base_ref}`,b=i(["show-ref","--verify","--quiet",l],e.repo_root);if(b.status===0){const c=i(["rev-parse","--verify",l],e.repo_root);c.status===0&&u.push({ref:l,sha:c.stdout.trim()})}else if(b.status!==1)return null}for(const l of u)if(i(["merge-base","--is-ancestor",o,l.sha],e.repo_root).status===0)return{branchSha:o,containingRef:l.ref,containingSha:l.sha};return null}a(P,"proveAbsentPathManagedWorktree");function X(e){return`The recorded checkout path is gone, but crtr cannot prove ${e.branch} is already delivered. Push or land ${e.branch}, then rerun \`crtr push final\`; if you cannot establish what happened to the branch, ask the user with \`crtr human send\`.`}a(X,"missingWorktreeRecoveryHint");function L(e){if(e.state!=="open"||!k(e.path)||M(e.path))return null;const r=i(["rev-parse","--abbrev-ref","HEAD"],e.path);if(r.status!==0||r.stdout.trim()!==e.branch)return null;const t=i(["status","--porcelain"],e.path);if(t.status!==0||t.stdout.trim()!=="")return null;const n=i(["rev-parse","HEAD"],e.path);if(n.status!==0)return null;const o=n.stdout.trim();let s;try{s=A(e.path,e.base_ref)}catch(h){if(h instanceof f&&h.code==="missing_base_branch"&&o===e.base_sha)return{branchSha:o,baseSha:e.base_sha};throw h}return i(["merge-base","--is-ancestor",o,s],e.path).status!==0?null:{branchSha:o,baseSha:s}}a(L,"proveCleanEmptyManagedWorktree");function z(e,r,t){if(k(r.path))return null;if(t.branchSha===null)return y(e,r,"complete"),{node_id:e,branch:r.branch,worktree_path:r.path,worktree_removed:!0,branch_deleted:!0};if(t.containingRef===void 0||t.containingSha===void 0)return null;const{branchDeleted:n}=Te(r,t.branchSha,t.containingRef,t.containingSha);return n?(y(e,r,"complete"),{node_id:e,branch:r.branch,worktree_path:r.path,worktree_removed:!0,branch_deleted:!0}):null}a(z,"autoDropAbsentPathManagedWorktreeLocked");function Pe(e,r,t){const n=L(r);return n===null||n.branchSha!==t.branchSha?null:(y(e,r,"pending"),{node_id:e,branch:r.branch,worktree_path:r.path,...T(r)})}a(Pe,"autoDropCleanManagedWorktreeLocked");function Q(e){if(e.state!=="open"||!k(e.path)||M(e.path))return null;const r=i(["status","--porcelain"],e.path);if(r.status!==0||r.stdout.trim()!=="")return null;const t=i(["rev-parse","HEAD"],e.path);return t.status===0?t.stdout.trim():null}a(Q,"cleanCurrentCheckoutTip");async function Qe(e){const r=Q(e);if(r===null)return!1;const t=process.env.GIT_SSH_COMMAND??process.env.GIT_SSH??"ssh",n=await ae(["ls-remote","--exit-code","--heads","origin"],e.path,void 0,{timeoutMs:1e4,env:{...process.env,GIT_TERMINAL_PROMPT:"0",GIT_SSH_COMMAND:`${t} -o BatchMode=yes`}});return n.status!==0||!n.stdout.split(`
+`).some(s=>{const[u,h]=s.split("	",2);return u===r&&h?.startsWith("refs/heads/")===!0})?!1:Q(e)===r}a(Qe,"branchIsPushedAtCurrentTip");function Je(e){const r=x(e);if(r===null)return null;const t=!k(r.path);return(t?P(r)===null:L(r)===null)?null:E(t?r.repo_root:r.path,()=>{const n=x(e);if(n===null)return null;if(!k(n.path)){const s=P(n);return s===null?null:z(e,n,s)}const o=L(n);return o===null?null:Pe(e,n,o)})}a(Je,"autoDropCleanManagedWorktree");export{$e as WORKTREE_LOCK_WAIT_MS,f as WorktreeError,Je as autoDropCleanManagedWorktree,Pe as autoDropCleanManagedWorktreeLocked,Qe as branchIsPushedAtCurrentTip,q as checkoutPathForBranchInList,ze as closeManagedWorktree,Xe as createManagedWorktree,Ke as hasOpenManagedWorktree,ke as isManagedWorktreeBase,M as isRebaseInProgress,me as managedWorktreePath,I as managedWorktreesRoot,X as missingWorktreeRecoveryHint,x as openManagedWorktreeForNode,y as persistClosedWorktreeState,L as proveCleanEmptyManagedWorktree,Ue as rollbackManagedWorktree,we as samePath,ye as worktreeLockPathForCommonDir};

package/dist/daemon/analytics/compute.d.ts

@@ -0,0 +1,37 @@
+import type { AnalyticsDTO, AnalyticsWindow } from '../../api/dto/analytics.js';
+import type { ScanInput, ScanResult } from './scan.js';
+export declare const WINDOW_MS: Record<AnalyticsWindow, number>;
+export interface AgentInput {
+    node_id: string;
+    name: string;
+    title: string | null;
+    kind: string;
+    parent: string | null;
+    cwd: string;
+    created: string;
+    finalized_at: string | null;
+    final_report: string | null;
+    lifecycle: 'resident' | 'terminal';
+    transcripts: string[];
+}
+export interface MemoryReadInput {
+    node_id: string;
+    name: string;
+    scope: string;
+    at: string;
+    type: 'read' | 'loaded';
+}
+export interface ComputeInput {
+    asOfMs: number;
+    window: AnalyticsWindow;
+    project: string | null;
+    /** Non-`human` node rows only. */
+    agents: AgentInput[];
+    scan: (input: ScanInput) => Promise<ScanResult>;
+    /** Throws when the memory-read log cannot be read. */
+    memory: (fromIso: string, toIso: string) => {
+        rows: MemoryReadInput[];
+        startedAt: string | null;
+    };
+}
+export declare function computeAnalytics(input: ComputeInput): Promise<AnalyticsDTO>;

package/dist/daemon/analytics/compute.js

@@ -0,0 +1 @@
+var L=Object.defineProperty;var u=(o,_)=>L(o,"name",{value:_,configurable:!0});const oe=36e5,Q={"24h":864e5,"7d":6048e5};function b(o,_){return o[Math.max(0,Math.ceil(_/100*o.length)-1)]}u(b,"rank");function P(o){const _=[...o].sort((g,h)=>g-h);return{count:_.length,p10_ms:b(_,10),median_ms:b(_,50),p90_ms:b(_,90),max_ms:_[_.length-1]}}u(P,"stats");const C=u(o=>o.input+o.output+o.cache_read+o.cache_write,"tokensOf"),X=u(o=>o.input+o.cache_read+o.cache_write,"contextOf"),y=u(o=>`${o.provider}\0${o.model}`,"modelKey");function v(o,_,g){const h=o.get(_);h?h.push(g):o.set(_,[g])}u(v,"push");const W=u(o=>o instanceof Error?o.message:String(o),"reason");function Y(o){const _=new Map(o.map(i=>[i.node_id,i])),g=new Map,h=u((i,w)=>{const p=g.get(i.node_id);if(p)return p;const l=i.parent===null?void 0:_.get(i.parent);let f;const r={a:i,createdMs:Date.parse(i.created),finMs:i.finalized_at===null?null:Date.parse(i.finalized_at)};if(!l||w.has(l.node_id)){if(l)throw new Error(`parent cycle through node ${i.node_id}`);f={...r,graph:i.node_id,parent:null,depth:0}}else{w.add(i.node_id);const t=h(l,w);f={...r,graph:t.graph,parent:l.node_id,depth:t.depth+1}}return g.set(i.node_id,f),f},"place");for(const i of o)h(i,new Set);return g}u(Y,"placeAgents");async function ae(o){const _=o.asOfMs,g=_-Q[o.window],h=u(e=>e!==null&&e>=g&&e<_,"inW"),i=Y(o.agents),w=u(e=>i.get(e.graph),"rootOf"),p=u(e=>w(e).a.cwd,"projectOf"),l=new Map;for(const e of i.values()){const a=p(e);v(l,a,e)}let f=null,r="";try{const e=[...l.keys()],a=await Promise.all(e.map(m=>o.scan({nodes:l.get(m).map(S=>({node_id:S.a.node_id,created:S.a.created,transcripts:S.a.transcripts})),windowStartMs:g,asOfMs:_})));f=new Map(e.map((m,S)=>[m,a[S]]))}catch(e){r=`transcript scan failed: ${W(e)}`}const t=new Map;for(const e of f?.values()??[])for(const a of e.responses)v(t,a.node_id,a);const c=u(e=>(t.get(e)??[]).reduce((a,m)=>a+m.cost,0),"priceOf"),s=u(e=>(t.get(e)??[]).reduce((a,m)=>a+C(m),0),"tokensOfAgent"),n=new Map;for(const e of f?.values()??[]){for(const a of e.responses)v(n,a.node_id,a.at_ms);for(const a of e.unknown_at)v(n,a.node_id,a.at_ms)}const d=u(e=>(n.get(e)?.length??0)>0,"isActive"),k=new Map,A=new Set;for(const e of i.values()){if(!d(e.a.node_id))continue;const a=p(e);A.add(a),k.set(a,(k.get(a)??0)+c(e.a.node_id))}const T=[...A].map(e=>({cwd:e,api_price_estimate:k.get(e)??0})).sort((e,a)=>a.api_price_estimate-e.api_price_estimate||e.cwd.localeCompare(a.cwd)),M=[...i.values()].filter(e=>o.project===null||p(e)===o.project),F=new Set(M.map(e=>e.a.node_id)),j=u(e=>e.parent!==null&&h(e.createdMs),"spawned"),z=u(e=>h(e.finMs),"finished"),D=new Set,I=new Set,R=u((e,a)=>{for(let m=e;m&&!a.has(m.a.node_id);m=m.parent===null?void 0:i.get(m.parent))a.add(m.a.node_id)},"climb");for(const e of M)d(e.a.node_id)&&R(e,D),(d(e.a.node_id)||j(e)||z(e))&&R(e,I);const N=M.filter(e=>I.has(e.a.node_id)).map(e=>({node_id:e.a.node_id,name:e.a.name,kind:e.a.kind,graph_id:e.graph,in_graph_detail:D.has(e.a.node_id),parent:e.parent,depth:e.depth,created:e.a.created,finalized_at:e.a.finalized_at,lifecycle:e.a.lifecycle,active:d(e.a.node_id),spawned_in_window:j(e),finished_in_window:z(e),agent_time_ms:e.finMs===null?null:e.finMs-e.createdMs,api_price_estimate:c(e.a.node_id),tokens:s(e.a.node_id),responses:n.get(e.a.node_id)?.length??0,response_times_ms:[...n.get(e.a.node_id)??[]].sort((a,m)=>a-m),final_report_ref:e.a.final_report?`${e.a.node_id}:reports/${e.a.final_report}`:null})).sort((e,a)=>e.created.localeCompare(a.created)||e.node_id.localeCompare(a.node_id)),V=M.reduce((e,a)=>e===null||a.a.created<e?a.a.created:e,null),q=M.flatMap(e=>(n.get(e.a.node_id)??[]).map(a=>({node_id:e.a.node_id,at_ms:a}))),x=M.filter(e=>d(e.a.node_id)).length;let H=null,U=null;if(f){const e=[...f.entries()].filter(([a])=>o.project===null||a===o.project).map(([,a])=>a);H={total:e.reduce((a,m)=>a+m.transcripts.total,0),read:e.reduce((a,m)=>a+m.transcripts.read,0),unreadable:e.flatMap(a=>a.transcripts.unreadable)},U=e.reduce((a,m)=>a+m.unknown,0)}const O=u(()=>({ok:!1,reason:r}),"fail"),B=f?{ok:!0,value:Z(M,i,d,c,s,j)}:O(),G=f?{ok:!0,value:ee(M,z,q,o.window,_)}:O(),J=f?{ok:!0,value:te(M,t)}:O();let $,K=null;try{const e=o.memory(new Date(g).toISOString(),new Date(_).toISOString());K=e.startedAt;const a=e.rows.filter(m=>F.has(m.node_id));$=f?{ok:!0,value:{read:E(a.filter(m=>m.type==="read"),i,x,d),loaded:E(a.filter(m=>m.type==="loaded"),i,x,d)}}:O()}catch(e){$={ok:!1,reason:`memory-read log unavailable: ${W(e)}`}}return{as_of:new Date(_).toISOString(),window_start:new Date(g).toISOString(),window:o.window,project:o.project,projects:T,transcripts:H,unknown_responses:U,oldest_agent_created:V,memory_log_started_at:K,agents:N,graphs:B,time:G,usage:J,memory:$}}u(ae,"computeAnalytics");function Z(o,_,g,h,i,w){const p=new Map,l=new Map;for(const n of o){if(w(n)&&l.set(n.graph,(l.get(n.graph)??new Set).add(n.a.kind)),!g(n.a.node_id))continue;let d=p.get(n.graph);if(!d){const k=_.get(n.graph).a;d={graph_id:n.graph,name:k.title||k.name,root_deleted:k.parent!==null,cwd:k.cwd,root_kind:k.kind,root_lifecycle:k.lifecycle,root_created:k.created,active_agents:0,depth:0,api_price_estimate:0,tokens:0,spawned_kinds:[]},p.set(n.graph,d)}d.active_agents++,d.depth=Math.max(d.depth,n.depth),d.api_price_estimate+=h(n.a.node_id),d.tokens+=i(n.a.node_id)}for(const n of p.values())n.spawned_kinds=[...l.get(n.graph_id)??[]].sort();const f=[...p.values()].sort((n,d)=>d.api_price_estimate-n.api_price_estimate||n.graph_id.localeCompare(d.graph_id)),r=u(n=>n<=1?0:n<=5?1:n<=10?2:n<=20?3:4,"bucket"),t=[0,0,0,0,0];for(const n of f)t[r(n.active_agents)]++;const c=new Map;for(const n of o)w(n)&&c.set(n.a.kind,(c.get(n.a.kind)??0)+1);const s=["1","2\u20135","6\u201310","11\u201320","21+"];return{count:f.length,spawned:[...c.values()].reduce((n,d)=>n+d,0),deepest:f.reduce((n,d)=>Math.max(n,d.depth),0),graphs:f,size_buckets:s.map((n,d)=>({label:n,graphs:t[d]})),spawned_by_kind:[...c].map(([n,d])=>({kind:n,agents:d})).sort((n,d)=>d.agents-n.agents||n.kind.localeCompare(d.kind))}}u(Z,"graphsMeasure");function ee(o,_,g,h,i){const w=o.filter(_),p=new Map;for(const s of w)v(p,s.a.kind,s.finMs-s.createdMs);const l=h==="24h"?36e5:24*36e5,f=h==="24h"?24:7,r=i-f*l,t=Array.from({length:f},()=>new Set);for(const s of g)t[Math.floor((s.at_ms-r)/l)].add(s.node_id);const c=t.map((s,n)=>({start:new Date(r+n*l).toISOString(),agents:s.size}));return{all:w.length===0?null:P(w.map(s=>s.finMs-s.createdMs)),by_kind:[...p].map(([s,n])=>({kind:s,...P(n)})).sort((s,n)=>n.count-s.count||s.kind.localeCompare(n.kind)),activity:{bucket_ms:l,buckets:c,max:c.reduce((s,n)=>Math.max(s,n.agents),0)}}}u(ee,"timeMeasure");function te(o,_){const g=new Map,h=new Map,i=[];let w=0,p=0;for(const r of o)for(const t of _.get(r.a.node_id)??[]){const c=y(t);let s=g.get(c);s||(s={row:{provider:t.provider,model:t.model,responses:0,api_price_estimate:0,tokens:0,tokens_by_type:{cache_read:0,cache_write:0,input:0,output:0},cache_read_share:0,context:{median:0,p90:0,max:0,buckets:[0,0,0,0,0]}},contexts:[]},g.set(c,s));const n=X(t);s.row.responses++,s.row.api_price_estimate+=t.cost,s.row.tokens+=C(t),s.row.tokens_by_type.cache_read+=t.cache_read,s.row.tokens_by_type.cache_write+=t.cache_write,s.row.tokens_by_type.input+=t.input,s.row.tokens_by_type.output+=t.output,s.row.context.buckets[Math.min(4,Math.floor(n/5e4))]++,s.contexts.push(n),i.push(n),w+=t.cost,p+=C(t);const d=h.get(r.a.kind)??{price:0,tokens:0,byModel:new Map};d.price+=t.cost,d.tokens+=C(t),d.byModel.set(c,(d.byModel.get(c)??0)+1),h.set(r.a.kind,d)}const l=[...g.values()].map(({row:r,contexts:t})=>{const c=t.sort((n,d)=>n-d),s=r.tokens_by_type.input+r.tokens_by_type.cache_read+r.tokens_by_type.cache_write;return r.cache_read_share=s===0?0:r.tokens_by_type.cache_read/s,r.context.median=b(c,50),r.context.p90=b(c,90),r.context.max=c[c.length-1],r}),f=u(r=>{const[t,c]=r.split("\0");return{provider:t,model:c}},"keyOf");return i.sort((r,t)=>r-t),{api_price_estimate:w,tokens:p,median_context:i.length===0?null:b(i,50),models:l.sort((r,t)=>t.api_price_estimate-r.api_price_estimate||y(r).localeCompare(y(t))),legend:[...l].sort((r,t)=>t.responses-r.responses||t.api_price_estimate-r.api_price_estimate||y(r).localeCompare(y(t))).slice(0,4).map(r=>({provider:r.provider,model:r.model})),kinds:[...h].map(([r,t])=>({kind:r,api_price_estimate:t.price,tokens:t.tokens,responses_by_model:[...t.byModel].map(([c,s])=>({...f(c),responses:s})).sort((c,s)=>s.responses-c.responses||y(c).localeCompare(y(s)))})).sort((r,t)=>t.api_price_estimate-r.api_price_estimate||r.kind.localeCompare(t.kind))}}u(te,"usageMeasure");function E(o,_,g,h){const i=new Map;for(const p of o){const l=`${p.name}\0${p.scope}`;v(i,l,p)}const w=[...i.values()].map(p=>{const l=new Map;for(const t of p){const c=l.get(t.node_id);c?(c.reads++,t.at<c.first_at&&(c.first_at=t.at)):l.set(t.node_id,{reads:1,first_at:t.at})}const f=[...l].map(([t,c])=>{const s=_.get(t);return{node_id:t,kind:s.a.kind,name:s.a.name,graph_id:s.graph,reads:c.reads,first_at:c.first_at}}).sort((t,c)=>c.reads-t.reads||t.first_at.localeCompare(c.first_at)||t.node_id.localeCompare(c.node_id)),r=new Map;for(const t of f)r.set(t.kind,(r.get(t.kind)??0)+1);return{name:p[0].name,scope:p[0].scope,reads:p.length,agents:f.length,graphs:new Set(f.map(t=>t.graph_id)).size,readers_by_kind:[...r].map(([t,c])=>({kind:t,agents:c})).sort((t,c)=>c.agents-t.agents||t.kind.localeCompare(c.kind)),readers:f}}).sort((p,l)=>l.reads-p.reads||l.agents-p.agents||p.name.localeCompare(l.name)||p.scope.localeCompare(l.scope));return{entries:o.length,documents:w.length,agents_with_entry:new Set(o.filter(p=>h(p.node_id)).map(p=>p.node_id)).size,active_agents:g,rows:w}}u(E,"memoryView");export{Q as WINDOW_MS,ae as computeAnalytics};

package/dist/daemon/analytics/scan-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/daemon/analytics/scan-worker.js

@@ -0,0 +1,2 @@
+var b=Object.defineProperty;var d=(e,a)=>b(e,"name",{value:a,configurable:!0});import{createReadStream as M}from"node:fs";import{stat as k}from"node:fs/promises";import{parentPort as N,workerData as S}from"node:worker_threads";const p=d(e=>typeof e=="number"&&Number.isFinite(e),"num");async function O(e){const a=[],i=[],c=new Set;let f=0;const o=[],m=d((t,h,u)=>{if(!u||typeof u!="object")return;const{type:l,message:r}=u;if(l!=="message"||!r||r.role!=="assistant"||r.stopReason==="error")return;const n=r.timestamp;if(!p(n)||n<e.windowStartMs||n>=e.asOfMs||n<h)return;const w=r.responseId;if(typeof w=="string"&&w!==""){if(c.has(w))return;c.add(w)}const s=r.usage,y=s?.cost?.total,{provider:_,model:g}=r;if(typeof _!="string"||_===""||typeof g!="string"||g===""||!s||!p(s.input)||!p(s.output)||!p(s.cacheRead)||!p(s.cacheWrite)||!p(y)){o.push({node_id:t,at_ms:n});return}a.push({node_id:t,at_ms:n,provider:_,model:g,input:s.input,output:s.output,cache_read:s.cacheRead,cache_write:s.cacheWrite,cost:y})},"take");for(const t of e.nodes){const h=Date.parse(t.created);if(!Number.isFinite(h))throw new Error(`node ${t.node_id} has an unparseable created time: ${t.created}`);for(const u of t.transcripts){f++;let l;try{l=(await k(u)).mtimeMs}catch(n){i.push({node_id:t.node_id,reason:n.code==="ENOENT"?"file missing":"unreadable"});continue}if(l<e.windowStartMs)continue;const r=await R(u,n=>m(t.node_id,h,n));r&&i.push({node_id:t.node_id,reason:r})}}return{responses:a,transcripts:{total:f,read:f-i.length,unreadable:i},unknown:o.length,unknown_at:o}}d(O,"run");async function R(e,a){let i=!1,c="";const f=d(o=>{if(o.trim()!=="")try{a(JSON.parse(o))}catch{i=!0}},"parse");try{for await(const o of M(e,{encoding:"utf8"})){const m=(c+o).split(`
+`);c=m.pop()??"";for(const t of m)f(t)}}catch{return"unreadable"}if(c.trim()!=="")try{a(JSON.parse(c))}catch{}return i?"parse error":null}d(R,"scanFile"),N?.postMessage(await O(S));