factory-factory 0.4.1 → 0.4.3

package/prisma/schema.prisma

@@ -68,14 +68,12 @@ enum CIStatus {
   FAILURE   // One or more checks failed
 }
 
-enum KanbanColumn {
-  WORKING
-  WAITING
-  DONE
-}
-
+/// Derived, never stored: computed from `WorkspacePR` by `deriveRatchetState`.
+/// It stays declared here so `src/shared/core/enums.ts` keeps a schema-side pair
+/// to be drift-checked against, and because it is still the vocabulary the
+/// snapshot stream and the v4 export format speak.
 enum RatchetState {
-  IDLE              // No PR or ratchet not active for this workspace
+  IDLE              // No PR, PR closed, or ratchet disabled for this workspace
   CI_RUNNING        // CI checks in progress
   CI_FAILED         // CI checks failed
   MERGE_CONFLICT    // PR has merge conflicts with the base branch
@@ -217,16 +215,6 @@ model Workspace {
   initScriptPid       Int?              // Process ID of running startup/setup script
   initRetryCount      Int                 @default(0)
 
-  // Run script tracking (from factory-factory.json)
-  runScriptCommand        String?           // The run script command to execute
-  runScriptPostRunCommand String?           // The postRun script command to execute after run is RUNNING
-  runScriptCleanupCommand String?           // The cleanup script command to execute on stop
-  runScriptPid            Int?              // Process ID of running script
-  runScriptPort           Int?              // Allocated port for the running script
-  runScriptStartedAt      DateTime?         // When the run script was started
-  runScriptStatus         RunScriptStatus   @default(IDLE)  // Run script runtime status
-
-  prUrl               String?
   githubIssueNumber   Int?
   githubIssueUrl      String?
   linearIssueId         String?   // Linear issue UUID
@@ -240,41 +228,19 @@ model Workspace {
   createdAt           DateTime          @default(now())
   updatedAt           DateTime          @updatedAt
 
-  // PR tracking (cached from GitHub)
-  prNumber            Int?
-  prState             PRState           @default(NONE)
-  prReviewState       String?           // Raw GitHub review state
-  prCiStatus          CIStatus          @default(UNKNOWN)  // CI check status
-  prUpdatedAt         DateTime?         // Last PR sync time
-
-  // PR discovery scheduling
-  prDiscoveryLastCheckedAt DateTime?
-  prDiscoveryRetryCount    Int       @default(0)
-  prDiscoveryNextCheckAt   DateTime?
-
-  // CI failure tracking
-  prCiFailedAt        DateTime?         // When CI first failed (cleared on success)
-  prCiLastNotifiedAt  DateTime?         // Last time we notified about CI failure
-
-  // PR Review tracking
-  prReviewLastCheckedAt   DateTime?     // When PR review comments were last checked
-  prReviewLastCommentId   String?       // ID of the last processed review comment
-
-  // Ratchet tracking (centralized PR progression)
-  ratchetEnabled          Boolean       @default(true)    // Workspace-level ratchet toggle
-  ratchetState            RatchetState  @default(IDLE)    // Current state in the ratchet progression
-  ratchetLastCheckedAt    DateTime?                       // When ratchet last checked this workspace
-  ratchetActiveSessionId  String?                         // ID of active fixer session (if any)
-  ratchetLastCiRunId      String?                         // Misnomer (kept to avoid a migration): stores the full PR dispatch snapshot key (PR number + CI signature + review activity + merge conflict), not just a CI run id. Dedupes fixer dispatches.
-  ratchetDispatchOutcome  RatchetDispatchOutcome?         // Outcome of the last fixer dispatch for the snapshot key above (null = never dispatched)
-  ratchetDispatchRetryCount Int         @default(0)       // DIED re-dispatches consumed for the current snapshot key
-
-  // Auto-iteration tracking
-  mode                      WorkspaceMode         @default(STANDARD)
-  autoIterationStatus       AutoIterationStatus?
-  autoIterationConfig       Json?                 // { testCommand, targetDescription, maxIterations, testTimeoutSeconds, sessionRecycleInterval }
-  autoIterationProgress     Json?                 // { currentIteration, baselineMetricSummary, currentMetricSummary, counts, timestamps }
-  autoIterationSessionId    String?               // Active ACP session for auto-iteration loop
+  // PR tracking (cached from GitHub) — see WorkspacePR
+  pr                  WorkspacePR?
+
+  // Ratchet tracking (centralized PR progression) — see WorkspaceRatchet
+  ratchet             WorkspaceRatchet?
+
+  // Run script: the cached factory-factory.json commands and the process running
+  // one of them — see WorkspaceRunScript
+  runScript           WorkspaceRunScript?
+
+  // Auto-iteration: the mode discriminant and the loop's state — see
+  // WorkspaceAutoIteration
+  autoIteration       WorkspaceAutoIteration?
 
   // Periodic task link
   periodicTaskId        String?
@@ -290,23 +256,222 @@ model Workspace {
   // Activity tracking
   hasHadSessions      Boolean           @default(false)
 
-  // Cached kanban column (for list performance)
-  cachedKanbanColumn  KanbanColumn      @default(WAITING)
-  stateComputedAt     DateTime?         // Last kanban column computation
-
   @@index([projectId])
   @@index([status])
-  @@index([cachedKanbanColumn])
+  @@index([periodicTaskId])
   @@index([parentWorkspaceId])
   // Composite indexes for common query patterns
   @@index([projectId, status])
-  @@index([projectId, cachedKanbanColumn])
   @@index([projectId, updatedAt])
   @@index([projectId, createdAt])
-  @@index([status, prUrl])
-  @@index([status, prUrl, prDiscoveryNextCheckAt])
-  @@index([status, prUpdatedAt])
-  @@index([status, ratchetEnabled, ratchetLastCheckedAt])
+  // The three composite indexes that used to lead with `status` and continue
+  // into `prUrl` / `prUpdatedAt` / `prDiscoveryNextCheckAt` are gone with those
+  // columns. Their queries now filter `status` here and the PR columns on
+  // WorkspacePR, which carries the matching indexes.
+}
+
+/// What GitHub last told us about the workspace's pull request, plus the
+/// bookkeeping for finding that PR and for the notifications we derive from it.
+///
+/// This is a cache, not a source of truth: every field here is either a copy of
+/// GitHub state or a cursor into it, and losing the whole row costs one refresh.
+/// It is split out of `Workspace` because that distinction was invisible while
+/// the columns sat beside the workspace's own durable identity, and because the
+/// compare-and-swap writes that attach and refresh a PR need to guard a row no
+/// other concern writes.
+///
+/// Field names drop the `pr` prefix the columns carried on `Workspace`, where it
+/// was doing the work this model's name now does. The flat `pr*` names are still
+/// what every caller sees: `workspacePrAccessor` maps between the two, so the
+/// split stops at the accessor.
+///
+/// Exactly one row per workspace, created with the workspace, so the writes that
+/// run before a PR exists — discovery claims and their backoff — have a row to
+/// guard. Reads substitute defaults if a row is ever missing rather than making
+/// every caller handle the null.
+model WorkspacePR {
+  workspaceId String    @id
+  workspace   Workspace @relation(fields: [workspaceId], references: [id], onDelete: Cascade)
+
+  url         String?                      // The attached PR, or null while none is known
+  number      Int?
+  state       PRState   @default(NONE)
+  reviewState String?                      // Raw GitHub review state
+  ciStatus    CIStatus  @default(UNKNOWN)  // CI check status
+  // GitHub's `mergeStateStatus == DIRTY`. Observed on every PR fetch but, until
+  // `RatchetState` became a projection, only ever stored as the derived
+  // `MERGE_CONFLICT` enum value -- so a restart lost the distinction between "no
+  // conflict" and "conflict we had folded into a state".
+  hasMergeConflict Boolean @default(false)
+  // When this cache was last written, not GitHub's PR `updated_at`: every caller
+  // passes its own observation time. Callers still say `prUpdatedAt`, which is
+  // why the old column read as PR metadata; `syncedAt` is what it always held.
+  syncedAt    DateTime?
+
+  // Discovery: locating the PR for the workspace's branch, with backoff.
+  discoveryLastCheckedAt DateTime?
+  discoveryRetryCount    Int       @default(0)
+  discoveryNextCheckAt   DateTime?
+
+  // CI failure notification bookkeeping.
+  ciFailedAt       DateTime?               // When CI first failed (cleared on success)
+  ciLastNotifiedAt DateTime?               // Last time we notified about CI failure
+
+  // Review comment cursor.
+  reviewLastCheckedAt DateTime?            // When PR review comments were last checked
+  reviewLastCommentId String?              // ID of the last processed review comment
+
+  // Discovery seeks on `url IS NULL` plus a due time, so it wants both columns in
+  // one index; a leftmost-prefix scan also serves plain `url` lookups. Sync
+  // filters `url IS NOT NULL` and orders by `syncedAt`, and because that filter
+  // is a range on the leading column, a composite there would cost an ordering
+  // scan rather than save one -- measured with EXPLAIN QUERY PLAN.
+  @@index([url, discoveryNextCheckAt])
+  @@index([syncedAt])
+}
+
+/// What the ratchet decides for one workspace: whether it is watching the PR,
+/// and the last fixer dispatch it made.
+///
+/// Deliberately not the ratchet's *state*. `RatchetState` is a projection of the
+/// PR observation on `WorkspacePR` (see `deriveRatchetState`), so it is computed
+/// at read time and there is nothing here to keep in step with the PR cache.
+/// What remains is genuinely mutable: a user-owned toggle and a dispatch record
+/// with real concurrency, whose conditional writes guard `enabled` alongside the
+/// field they set — which is why the toggle lives next to the dispatch record
+/// rather than back on `Workspace`.
+///
+/// Exactly one row per workspace, created with the workspace. Reads go through
+/// `workspaceRatchetAccessor`, which substitutes these defaults if a row is
+/// ever missing (a pre-split backup restored, say) rather than making every
+/// caller handle the null.
+model WorkspaceRatchet {
+  workspaceId String    @id
+  workspace   Workspace @relation(fields: [workspaceId], references: [id], onDelete: Cascade)
+
+  enabled       Boolean   @default(true)      // Workspace-level ratchet toggle
+  lastCheckedAt DateTime?                     // When the ratchet last checked this workspace
+
+  // The last fixer dispatch, keyed by the PR state it was dispatched for.
+  activeSessionId     String?                 // Active fixer session (if any)
+  dispatchSnapshotKey String?                 // PR number + CI signature + review activity + merge conflict. Dedupes fixer dispatches.
+  dispatchOutcome     RatchetDispatchOutcome? // Outcome for the key above (null = never dispatched, or reset by a PR change)
+  dispatchRetryCount  Int          @default(0) // DIED re-dispatches consumed for the current key
+
+  // The ratchet's own conclusion that it will not act again until the PR
+  // changes: either a settled dispatch achieved nothing for an unchanged
+  // snapshot key, or a DIED fixer exhausted its retries. Persisted because the
+  // snapshot key hashes statusCheckRollup detail `WorkspacePR` does not store,
+  // so no reader can re-derive this.
+  dispatchStalled     Boolean      @default(false)
+
+  // The poll set is `enabled` workspaces, oldest check first. Dropping `state`
+  // from the composite left `enabled` alone, which a boolean index cannot help
+  // with at this cardinality, so only the ordering index remains.
+  @@index([lastCheckedAt])
+}
+
+/// The workspace's dev server: the commands `factory-factory.json` declares for
+/// it, and the process currently running one of them.
+///
+/// Two groups in one row, on purpose. `command` / `postRunCommand` /
+/// `cleanupCommand` are a cache of the config file in the worktree; `pid` /
+/// `port` / `startedAt` / `status` describe a live process. They share a row
+/// because they share a writer — `workspaceRunScriptService` is the only thing
+/// that writes either — so splitting them would produce two accessors guarding
+/// the same boundary, and because every read that wants one wants the workspace
+/// anyway. Nothing here is written together across the groups, so no write
+/// spans them.
+///
+/// The config group stays a cache rather than becoming a projection the way
+/// `cachedKanbanColumn` and `RatchetState` did, and the reason is where the
+/// source of truth lives. Those two were derived from other columns, so
+/// computing them at read time cost nothing; these come from a file in the
+/// worktree, and deriving them on read would mean a filesystem call per
+/// workspace per list query. Drift is repaired at the point of use instead:
+/// `reconcileWorkspaceCommandCache` re-reads the file before starting or
+/// stopping a script and writes back what it finds.
+///
+/// The runtime group is persisted even though a restart invalidates the process,
+/// because `pid` is the only handle on an orphan. Run scripts spawn with
+/// `detached: false`, so they normally die with the server -- but a SIGKILL or a
+/// crash leaves them running, and `verifyRunning` finds them again with
+/// `process.kill(pid, 0)` against this column. `resetStaleTransientStatuses`
+/// clears `STARTING` / `STOPPING` at startup for the same reason: those two
+/// cannot survive the process that was mid-transition.
+///
+/// Exactly one row per workspace, created with the workspace, so the
+/// compare-and-swap on `status` always has a row to guard. Reads substitute
+/// defaults if a row is ever missing rather than making every caller handle the
+/// null.
+///
+/// One consequence of the split, the same one the PR cache had: these writes no
+/// longer touch `Workspace.updatedAt`, because Prisma's `@updatedAt` only fires
+/// for the table being written. So starting or stopping a run script no longer
+/// floats its workspace up the sidebar and board, which order by `updatedAt`.
+/// That is deliberate -- a process exiting was never workspace activity, and the
+/// activity the UI actually displays (`lastActivityAt`) is computed from session
+/// timestamps, not this column. It also stops a busy run script from holding
+/// `updatedAt` fresh enough to defer the stale-ARCHIVING recovery sweep.
+model WorkspaceRunScript {
+  workspaceId String    @id
+  workspace   Workspace @relation(fields: [workspaceId], references: [id], onDelete: Cascade)
+
+  // Cached from factory-factory.json in the worktree.
+  command        String?                    // The run script command to execute
+  postRunCommand String?                    // Runs after the run script reaches RUNNING
+  cleanupCommand String?                    // Runs on stop
+
+  // The process, if one is running.
+  pid       Int?                            // Process ID of running script
+  port      Int?                            // Allocated port for the running script
+  startedAt DateTime?                       // When the run script was started
+  status    RunScriptStatus @default(IDLE)   // Run script runtime status
+
+  // Startup recovery scans `status IN ('STARTING','STOPPING')`, which at this
+  // table's size is a scan either way; the pre-split column had no index and
+  // this one does not need one. Nothing else filters or orders on these columns.
+}
+
+/// The auto-iteration loop's state, split off `Workspace` (issue: the model
+/// carried six unrelated concerns). After creation it is written only by
+/// `workspace-auto-iteration.accessor.ts`; the row itself is created with its
+/// workspace by `workspaceAccessor.create`, which sets `mode` and `config` from
+/// the creation input and is the one other writer the ownership rule permits.
+/// Reads are flattened back onto the workspace under the old
+/// `mode`/`autoIteration*` names, so the v4 export format and the client are
+/// unchanged.
+///
+/// `mode` travels with the group rather than staying on `Workspace`. It reads
+/// like a general workspace attribute, but every consumer is an auto-iteration
+/// consumer: the kanban card gates its badge on it, the right panel and the
+/// progress banner derive `isAutoIteration` from it, creation only validates it
+/// against `autoIterationConfig`, and `auto-iteration.trpc.ts` uses it as an
+/// entry guard. It is this group's discriminant, so it is this group's column --
+/// the same call made for `ratchetEnabled` in the ratchet split.
+///
+/// Unlike the run script's, none of these fields are on the snapshot wire: the
+/// client's snapshot adapter lists all five under `mutationOnlyFieldDefaults`,
+/// because they change through explicit mutations rather than live activity.
+/// The v4 export carries only `mode` and `autoIterationConfig`, both already
+/// optional with defaults.
+///
+/// Same `updatedAt` consequence as the three splits before it: these writes no
+/// longer touch `Workspace.updatedAt`, so loop progress does not float its
+/// workspace up the sidebar and board. Deliberate, and consistent -- the
+/// activity the UI displays is computed from session timestamps.
+model WorkspaceAutoIteration {
+  workspaceId String    @id
+  workspace   Workspace @relation(fields: [workspaceId], references: [id], onDelete: Cascade)
+
+  mode      WorkspaceMode        @default(STANDARD)
+  status    AutoIterationStatus?
+  config    Json?                // { testCommand, targetDescription, maxIterations, testTimeoutSeconds, sessionRecycleInterval }
+  progress  Json?                // { currentIteration, baselineMetricSummary, currentMetricSummary, counts, timestamps }
+  sessionId String?              // Active ACP session for the loop
+
+  // Startup recovery scans `status = 'RUNNING'`; the pre-split column had no
+  // index and this one does not need one at this table's size.
 }
 
 model AgentSession {

package/dist/client/assets/arc-lK3Ig9GV.js

@@ -1 +0,0 @@
-import{al as ln,am as an,an as y,ao as tn,ap as H,aq as q,ar as _,as as un,at as rn,au as L,av as o,aw as B,ax as sn,ay as on,az as fn}from"./index-DEKuJM5_.js";function cn(l){return l.innerRadius}function yn(l){return l.outerRadius}function gn(l){return l.startAngle}function mn(l){return l.endAngle}function pn(l){return l&&l.padAngle}function dn(l,h,E,z,v,A,C,a){var I=E-l,s=z-h,n=C-v,m=a-A,u=m*I-n*s;if(!(u*u<y))return u=(n*(h-A)-m*(l-v))/u,[l+u*I,h+u*s]}function W(l,h,E,z,v,A,C){var a=l-E,I=h-z,s=(C?A:-A)/L(a*a+I*I),n=s*I,m=-s*a,u=l+n,i=h+m,f=E+n,c=z+m,F=(u+f)/2,t=(i+c)/2,p=f-u,g=c-i,R=p*p+g*g,T=v-A,P=u*c-f*i,O=(g<0?-1:1)*L(fn(0,T*T*R-P*P)),S=(P*g-p*O)/R,j=(-P*p-g*O)/R,w=(P*g+p*O)/R,d=(-P*p+g*O)/R,x=S-F,e=j-t,r=w-F,G=d-t;return x*x+e*e>r*r+G*G&&(S=w,j=d),{cx:S,cy:j,x01:-n,y01:-m,x11:S*(v/T-1),y11:j*(v/T-1)}}function hn(){var l=cn,h=yn,E=B(0),z=null,v=gn,A=mn,C=pn,a=null,I=ln(s);function s(){var n,m,u=+l.apply(this,arguments),i=+h.apply(this,arguments),f=v.apply(this,arguments)-an,c=A.apply(this,arguments)-an,F=un(c-f),t=c>f;if(a||(a=n=I()),i<u&&(m=i,i=u,u=m),!(i>y))a.moveTo(0,0);else if(F>tn-y)a.moveTo(i*H(f),i*q(f)),a.arc(0,0,i,f,c,!t),u>y&&(a.moveTo(u*H(c),u*q(c)),a.arc(0,0,u,c,f,t));else{var p=f,g=c,R=f,T=c,P=F,O=F,S=C.apply(this,arguments)/2,j=S>y&&(z?+z.apply(this,arguments):L(u*u+i*i)),w=_(un(i-u)/2,+E.apply(this,arguments)),d=w,x=w,e,r;if(j>y){var G=sn(j/u*q(S)),M=sn(j/i*q(S));(P-=G*2)>y?(G*=t?1:-1,R+=G,T-=G):(P=0,R=T=(f+c)/2),(O-=M*2)>y?(M*=t?1:-1,p+=M,g-=M):(O=0,p=g=(f+c)/2)}var J=i*H(p),K=i*q(p),N=u*H(T),Q=u*q(T);if(w>y){var U=i*H(g),V=i*q(g),X=u*H(R),Y=u*q(R),D;if(F<rn)if(D=dn(J,K,X,Y,U,V,N,Q)){var Z=J-D[0],$=K-D[1],k=U-D[0],b=V-D[1],nn=1/q(on((Z*k+$*b)/(L(Z*Z+$*$)*L(k*k+b*b)))/2),en=L(D[0]*D[0]+D[1]*D[1]);d=_(w,(u-en)/(nn-1)),x=_(w,(i-en)/(nn+1))}else d=x=0}O>y?x>y?(e=W(X,Y,J,K,i,x,t),r=W(U,V,N,Q,i,x,t),a.moveTo(e.cx+e.x01,e.cy+e.y01),x<w?a.arc(e.cx,e.cy,x,o(e.y01,e.x01),o(r.y01,r.x01),!t):(a.arc(e.cx,e.cy,x,o(e.y01,e.x01),o(e.y11,e.x11),!t),a.arc(0,0,i,o(e.cy+e.y11,e.cx+e.x11),o(r.cy+r.y11,r.cx+r.x11),!t),a.arc(r.cx,r.cy,x,o(r.y11,r.x11),o(r.y01,r.x01),!t))):(a.moveTo(J,K),a.arc(0,0,i,p,g,!t)):a.moveTo(J,K),!(u>y)||!(P>y)?a.lineTo(N,Q):d>y?(e=W(N,Q,U,V,u,-d,t),r=W(J,K,X,Y,u,-d,t),a.lineTo(e.cx+e.x01,e.cy+e.y01),d<w?a.arc(e.cx,e.cy,d,o(e.y01,e.x01),o(r.y01,r.x01),!t):(a.arc(e.cx,e.cy,d,o(e.y01,e.x01),o(e.y11,e.x11),!t),a.arc(0,0,u,o(e.cy+e.y11,e.cx+e.x11),o(r.cy+r.y11,r.cx+r.x11),t),a.arc(r.cx,r.cy,d,o(r.y11,r.x11),o(r.y01,r.x01),!t))):a.arc(0,0,u,T,R,t)}if(a.closePath(),n)return a=null,n+""||null}return s.centroid=function(){var n=(+l.apply(this,arguments)+ +h.apply(this,arguments))/2,m=(+v.apply(this,arguments)+ +A.apply(this,arguments))/2-rn/2;return[H(m)*n,q(m)*n]},s.innerRadius=function(n){return arguments.length?(l=typeof n=="function"?n:B(+n),s):l},s.outerRadius=function(n){return arguments.length?(h=typeof n=="function"?n:B(+n),s):h},s.cornerRadius=function(n){return arguments.length?(E=typeof n=="function"?n:B(+n),s):E},s.padRadius=function(n){return arguments.length?(z=n==null?null:typeof n=="function"?n:B(+n),s):z},s.startAngle=function(n){return arguments.length?(v=typeof n=="function"?n:B(+n),s):v},s.endAngle=function(n){return arguments.length?(A=typeof n=="function"?n:B(+n),s):A},s.padAngle=function(n){return arguments.length?(C=typeof n=="function"?n:B(+n),s):C},s.context=function(n){return arguments.length?(a=n??null,s):a},s}export{hn as d};