@gitroll/tacitt-cli 0.0.0-stage → 0.1.0

package/skills/tacitt/scripts/journey-classification-progress.mjs

@@ -0,0 +1,194 @@
+import { hash, optional } from './journey-state.mjs'
+import { answers } from './journey-tasks.mjs'
+import { readFile } from 'node:fs/promises'
+import {
+  validateClassificationJudgment,
+  validateClassificationProject,
+} from './journey-classification-validation.mjs'
+
+function inputFingerprint(view, rootIds) {
+  return hash({
+    snapshotId: view.snapshotId,
+    roots: rootIds,
+  })
+}
+
+export async function classificationProgress(manifest) {
+  const classification = manifest.classification
+  if (!classification)
+    return {
+      generationComplete: false,
+      fixedProjects: 0,
+      remainingRoots: 0,
+      unresolvedRoots: 0,
+      generatedTasks: 0,
+      pendingAnswers: 0,
+    }
+  const pendingAnswers = (
+    await Promise.all(manifest.tasks.map((item) => optional(item.answer)))
+  ).filter((answer) => !answer).length
+  const assigned = new Set(manifest.tasks.flatMap((item) => item.rootKeys ?? []))
+  const assignedProjects = new Set(manifest.tasks.flatMap((item) => item.projectKeys ?? []))
+  return {
+    generationComplete: classification.complete,
+    routingMs: classification.routingMs ?? null,
+    fixedProjects: classification.projects.length,
+    unresolvedRoots: classification.unknown.length,
+    remainingRoots:
+      classification.unknown.filter((root) => !assigned.has(root.rootKey)).length +
+      classification.projects
+        .filter((project) => !assignedProjects.has(project.key))
+        .reduce((sum, project) => sum + project.rootKeys.length, 0),
+    generatedTasks: manifest.tasks.length,
+    pendingAnswers,
+  }
+}
+
+/** Publish counts derived from validated per-root task receipts and proposal coverage. */
+export async function publishClassificationProgress(
+  manifest,
+  view,
+  call,
+  {
+    status = 'running',
+    stage = manifest.consolidation ? 'proposal' : 'classification',
+    proposalRevision = null,
+  } = {},
+) {
+  const classification = manifest.classification
+  if (!classification) return
+  const rootIds = classification.roots
+    .map((root) => root.rootSessionId)
+    .toSorted((left, right) => left.localeCompare(right))
+  const knownKeys = new Set(classification.projects.flatMap((project) => project.rootKeys))
+  const aiCompleted = new Set()
+  const completed = new Set()
+  const latestJudgments = new Set()
+  for (const item of manifest.tasks) {
+    if (item.evidenceRound > 0 && !(await optional(item.answer))) continue
+    if (item.projectKeys) {
+      const assigned = item.projectKeys
+      const projects = await answers([item], 'items').catch((error) => {
+        if (error.code === 'ENOENT') return []
+        throw error
+      })
+      const ids = projects.map((project) => project.projectId)
+      const expectedIds = classification.projects
+        .filter((project) => assigned.includes(project.key))
+        .map((project) => project.projectId)
+      if (
+        ids.length === expectedIds.length &&
+        new Set(ids).size === ids.length &&
+        expectedIds.every((id) => ids.includes(id))
+      ) {
+        for (const project of projects) validateClassificationProject(project, project.projectId)
+        for (const project of classification.projects.filter((entry) =>
+          assigned.includes(entry.key),
+        )) {
+          for (const key of project.rootKeys) {
+            completed.add(key)
+            aiCompleted.add(key)
+          }
+        }
+      }
+      continue
+    }
+    if (!(await optional(item.answer))) continue
+    const judgments = await answers([item], 'judgments')
+    const answer = JSON.parse(await readFile(item.answer, 'utf8'))
+    const requestedEvidence = answer.evidenceRootKeys ?? []
+    if (
+      !Array.isArray(requestedEvidence) ||
+      requestedEvidence.some((key) => !item.rootKeys.includes(key))
+    )
+      throw new Error('INVALID_EVIDENCE_ROOTS')
+    if (item.evidenceRound > 0 && requestedEvidence.length)
+      throw new Error('EVIDENCE_ESCALATION_LIMIT')
+    const keys = judgments.map((judgment) => judgment.rootKey)
+    if (
+      keys.length !== item.rootKeys.length ||
+      new Set(keys).size !== keys.length ||
+      item.rootKeys.some((key) => !keys.includes(key))
+    )
+      continue
+    for (const judgment of judgments) validateClassificationJudgment(judgment, judgment.rootKey)
+    for (const key of keys) latestJudgments.add(key)
+    for (const key of requestedEvidence) latestJudgments.delete(key)
+  }
+  for (const key of latestJudgments) {
+    completed.add(key)
+    aiCompleted.add(key)
+  }
+  const grouped = new Set([...knownKeys].filter((key) => completed.has(key)))
+  const rootsByKey = new Map(classification.roots.map((root) => [root.key, root.rootSessionId]))
+  const completedRootIds = [...completed]
+    .map((key) => rootsByKey.get(key))
+    .filter(Boolean)
+    .toSorted((left, right) => left.localeCompare(right))
+  const groupedRootIds = [...grouped]
+    .map((key) => rootsByKey.get(key))
+    .filter(Boolean)
+    .toSorted((left, right) => left.localeCompare(right))
+  const aiCompletedRootIds = [...aiCompleted]
+    .map((key) => rootsByKey.get(key))
+    .filter(Boolean)
+    .toSorted((left, right) => left.localeCompare(right))
+  const startedAt = classification.startedAt ?? new Date().toISOString()
+  const updatedAt = new Date().toISOString()
+  await call('journey.classificationProgress', {
+    journeyId: view.journeyId,
+    kind: 'classification-progress',
+    id: 'current',
+    snapshotId: view.snapshotId,
+    baselineRevision: classification.baselineRevision,
+    proposalRevision,
+    inputFingerprint: inputFingerprint(view, rootIds),
+    stage,
+    status,
+    startedAt,
+    updatedAt,
+    elapsedMs: Math.max(0, Date.parse(updatedAt) - Date.parse(startedAt)),
+    rootIds,
+    completedRootIds,
+    groupedRootIds,
+    aiCompletedRootIds,
+  })
+}
+
+/** Fail only the exact running checkpoint already accepted by the backend. */
+export async function publishFailedClassificationProgress(manifest, view, call) {
+  const classification = manifest.classification
+  const prior = view.classificationProgress
+  if (!classification || !prior || prior.status !== 'running') return
+  const rootIds = classification.roots
+    .map((root) => root.rootSessionId)
+    .toSorted((left, right) => left.localeCompare(right))
+  if (
+    view.revision !== classification.baselineRevision ||
+    prior.baselineRevision !== classification.baselineRevision ||
+    prior.startedAt !== classification.startedAt ||
+    prior.snapshotId !== view.snapshotId ||
+    prior.inputFingerprint !== inputFingerprint(view, rootIds) ||
+    JSON.stringify(prior.rootIds) !== JSON.stringify(rootIds)
+  )
+    return
+  const updatedAt = new Date().toISOString()
+  await call('journey.classificationProgress', {
+    journeyId: view.journeyId,
+    kind: 'classification-progress',
+    id: 'current',
+    snapshotId: prior.snapshotId,
+    baselineRevision: prior.baselineRevision,
+    proposalRevision: null,
+    inputFingerprint: prior.inputFingerprint,
+    stage: prior.stage,
+    status: 'failed',
+    startedAt: prior.startedAt,
+    updatedAt,
+    elapsedMs: Math.max(0, Date.parse(updatedAt) - Date.parse(prior.startedAt)),
+    rootIds: prior.rootIds,
+    completedRootIds: prior.completedRootIds,
+    groupedRootIds: prior.groupedRootIds,
+    aiCompletedRootIds: prior.aiCompletedRootIds,
+  })
+}

package/skills/tacitt/scripts/journey-classification-tasks.d.mts

@@ -0,0 +1,18 @@
+export function classificationTasks(
+  directory: string,
+  manifest: {
+    tasks: Array<Record<string, unknown>>
+    classification?: {
+      unknown: Array<{ metadata: Record<string, unknown> }>
+      [key: string]: unknown
+    }
+    [key: string]: unknown
+  },
+  view: unknown,
+  call: (procedure: string, input: Record<string, unknown>) => Promise<unknown>,
+  limit: number,
+): Promise<{
+  tasks: Array<Record<string, unknown>>
+  stalled?: Array<{ id: string; ageMs: number }>
+  created: number
+}>

package/skills/tacitt/scripts/journey-classification-tasks.mjs

@@ -0,0 +1,345 @@
+import { stat } from 'node:fs/promises'
+import { join } from 'node:path'
+import { optional, save } from './journey-state.mjs'
+import { task, taskTokens } from './journey-tasks.mjs'
+import { classificationProgress } from './journey-classification-progress.mjs'
+
+const budget = 12000
+/** A task unpublished this long after it was written has a stalled child (ADR 0207). */
+const STALLED_MS = 900_000
+// One bounded family per line; retain all evidence while avoiding repeated pretty-print whitespace.
+const formatRoots = (data) =>
+  `{"knownProjects":[\n${data.knownProjects.map((row) => JSON.stringify(row)).join(',\n')}\n],"families":[\n${data.families.map((row) => JSON.stringify(row)).join(',\n')}\n]}`
+export const classifyInstruction =
+  'Classify every assigned root family from compact metadata and partial structural project evidence. No privacy detection. Return {judgments:[{rootKey,projectName,workIntent,groupingBasis,targetProjectId?}],evidenceRootKeys:[]}. One judgment per rootKey; rootKey is an opaque handle, never invent or omit one. Before creating any new project, topic or Unsorted judgment, compare this root against every entry in knownProjects. Use targetProjectId only when that exact known project identity is supported; it must be the exact catalog projectId. Never select identity by display-name match. A targetProjectId becomes a fixed constraint in reconciliation: for genuinely cross-project roots with ambiguous or incomplete evidence, repository reference counts, change counts or apparent dominance cannot establish an owning project. Require direct evidence of this root’s owning intent before binding a target; otherwise omit targetProjectId, preserve the unresolved cross-project question in groupingBasis, and request one bounded evidence round only when it can resolve that question. An evidence request is not itself proof of ownership; bind only after its answer supports ownership. The known-project catalog is not exhaustive: an independently evidenced repository absent from it may establish a new project, including one root; omit targetProjectId for that new identity rather than treating catalog absence as Unsorted evidence. Exact complete supported repository evidence is positive identity evidence. Partial repository references are useful positive evidence but do not establish completeness; missing evidence is not negative proof. Independent content evidence can support a known project. Checking, using, connecting to, or integrating with a product/tool is not evidence that the root develops that product’s repository; require independent repository or content evidence before assigning project identity. A product topic may still be retained when roots genuinely share it. Scratch workspace name alone is insufficient, but do not ignore an exact repository reference or independent content evidence. projectName is a stable shared project or coherent theme name (<=240 chars), synthesized across the assigned roots, not a separate copy of each session title. Use the same name for roots with supported common identity or a genuinely shared topic. Use exactly Unsorted for one-off miscellaneous tasks with no supported project or meaningful shared theme; still preserve their concrete workIntent and groupingBasis so global reconciliation can reconsider them. Never create a project solely to keep a singleton. workIntent is a concrete short description of this root’s actual work, <=240 chars. If titleAvailable is false and no independent root-specific evidence establishes intent, explicitly state that intent is unknown; never invent an activity from a generated scratch/temp label or copy a sibling’s intent. Generated labels and sibling similarity alone cannot establish topic membership either. Keep such a root Unsorted with the missing evidence recorded, or request bounded evidence for a concrete membership-changing question. groupingBasis is concise evidence/uncertainty for grouping, <=200 chars. Do not produce Work descriptions, project types, visibility or recommendations here; those are assigned once during final grouping. Named ordinary source folders and corroborated project evidence can establish non-Git projects; generic home, scratch and temporary folders cannot. Titles alone do not prove a project. workspaceKind scratch, temp, home or unresolved is not an ordinary project folder: even a descriptive workspaceName may be generated from a chat title and cannot establish project identity. For those roots require independent project evidence before calling a new project; otherwise keep a theme or Unsorted and request bounded evidence only for a concrete membership-changing question. Preserve uncertainty in groupingBasis. Default evidenceRootKeys to empty. Request evidence only for a concrete unresolved identity question whose answer could change membership, and state that question in groupingBasis. Do not request evidence merely because a workspace lacks Git metadata, or blanket-request all roots of a named project your groupingBasis already supports. Missing project evidence can remain a provisional topic or Unsorted without proving a negative. A clear project remains independent with one root. Provisional topic evidence is useful across batches.'
+
+const projectInstruction =
+  'Describe fixed repository identities only. Return {items:[{projectId,description,projectType,recommendation:{access,reason}}]}. Every assigned projectId exactly once. Membership, identity and name are fixed and cannot be reclassified. Description states intended work; reason may state the grouping evidence. No original content or privacy scan. Recommend drop only when evidence shows no useful retained purpose; heterogeneous work, uncertainty or incomplete evidence alone is insufficient. Public means visible on the Passport after privacy masking; Private stays hidden but still counts. Recommend public for showcase work that demonstrates the person’s own skills, such as side projects, open-source or public repositories, coursework, hackathons, personal sites and tools, unless evidence ties it to employer or client confidentiality, internal systems or sensitive personal matters; recommend private for those. Missing privacy evidence alone is not a reason for private. Explain uncertainty in the reason. Recommendations are not approvals. Types: work, side, coursework, personal, scratch, other; access: public, private, drop.'
+
+const rootUniverse = (view) => {
+  const result = []
+  for (const work of view.works) {
+    for (const rootSessionId of work.rootSessionIds) {
+      result.push({ rootSessionId, workId: work.id })
+    }
+  }
+  return result
+}
+
+async function initialize(directory, manifest, view, call) {
+  if (manifest.classification) return
+  const works = new Map(view.works.map((work) => [work.id, work]))
+  const universe = rootUniverse(view)
+  const rootWork = new Map(universe.map((entry) => [entry.rootSessionId, entry.workId]))
+  const startedAt = new Date().toISOString()
+  const routingStart = performance.now()
+  const page = await call('journey.catalog', {
+    journeyId: view.journeyId,
+    after: 0,
+    limit: 1,
+    includeClassificationRouting: true,
+    includeProjectEvidence: true,
+  })
+  const routingMs = performance.now() - routingStart
+  const selected = page.classificationRouting
+  if (!selected) throw new Error('CLASSIFICATION_ROUTING_MISSING')
+  const known = selected.knownProjects ?? []
+  const unresolved = selected.unresolvedRoots ?? []
+  const assignments = selected.assignments ?? []
+  const knownRootIds = new Set(known.flatMap((project) => project.rootSessionIds))
+  const unresolvedIds = new Set(unresolved.map((root) => root.rootSessionId))
+  const assignmentByRoot = new Map(assignments.map((entry) => [entry.rootSessionId, entry]))
+  if (
+    knownRootIds.size !== known.flatMap((project) => project.rootSessionIds).length ||
+    unresolvedIds.size !== unresolved.length ||
+    assignments.length !== universe.length ||
+    assignmentByRoot.size !== universe.length ||
+    universe.some((root) => !assignmentByRoot.has(root.rootSessionId)) ||
+    knownRootIds.size + unresolvedIds.size !== universe.length ||
+    universe.some(
+      (root) => !knownRootIds.has(root.rootSessionId) && !unresolvedIds.has(root.rootSessionId),
+    ) ||
+    [...knownRootIds].some((id) => !rootWork.has(id)) ||
+    [...unresolvedIds].some((id) => !rootWork.has(id)) ||
+    known.some((project) =>
+      project.rootSessionIds.some(
+        (id) => assignmentByRoot.get(id)?.projectId !== project.repositoryId,
+      ),
+    ) ||
+    unresolved.some((root) => assignmentByRoot.get(root.rootSessionId)?.projectId !== null)
+  )
+    throw new Error('CLASSIFICATION_ROUTING_COVERAGE_INVALID')
+
+  const roots = universe.map((entry, index) => ({
+    key: `r${index + 1}`,
+    ...entry,
+  }))
+  const byId = new Map(roots.map((root) => [root.rootSessionId, root]))
+  const projects = known.map((project, index) => ({
+    projectId: project.repositoryId,
+    projectName: project.repositoryName,
+    rootKeys: project.rootSessionIds.map((id) => byId.get(id)?.key),
+    metadata: project,
+    key: `p${String(index + 1).padStart(4, '0')}`,
+  }))
+  if (projects.some((project) => project.rootKeys.some((key) => !key)))
+    throw new Error('CLASSIFICATION_ROUTING_COVERAGE_INVALID')
+  const projectRootKeys = new Set(projects.flatMap((project) => project.rootKeys))
+  const unknown = unresolved.map((item) => {
+    const root = byId.get(item.rootSessionId)
+    if (!root || projectRootKeys.has(root.key))
+      throw new Error('CLASSIFICATION_ROUTING_COVERAGE_INVALID')
+    const work = works.get(root.workId)
+    if (!work) throw new Error('CLASSIFICATION_ROUTING_COVERAGE_INVALID')
+    return {
+      rootKey: root.key,
+      metadata: {
+        workspaceKind: item.workspaceKind,
+        workspaceName: item.workspaceName,
+        harness: item.harness,
+        titleAvailable: item.titleAvailable,
+        memberCount: item.memberCount,
+        titles: item.titles,
+        projectEvidence: item.projectEvidence ?? null,
+      },
+    }
+  })
+  if (projectRootKeys.size + unknown.length !== roots.length)
+    throw new Error('CLASSIFICATION_ROUTING_COVERAGE_INVALID')
+  manifest.classification = {
+    roots,
+    projects,
+    unknown,
+    routingAssignments: assignments,
+    evidence: [],
+    complete: false,
+    startedAt,
+    routingMs,
+    baselineRevision: view.revision,
+  }
+  await save(join(directory, 'manifest.json'), manifest)
+}
+
+async function pendingTasks(manifest) {
+  const result = []
+  for (const item of manifest.tasks) if (!(await optional(item.answer))) result.push(item)
+  return result.sort(
+    (left, right) =>
+      Number(Boolean(right.rootKeys?.length)) - Number(Boolean(left.rootKeys?.length)),
+  )
+}
+
+export async function classificationTasks(directory, manifest, view, call, limit) {
+  await initialize(directory, manifest, view, call)
+  const state = manifest.classification
+  const created = []
+  const availableSlots = Math.max(0, Math.floor(limit))
+  const knownProjects = state.projects.map(({ projectId, projectName }) => ({
+    projectId,
+    projectName,
+  }))
+  // Existing assignments are immutable. Allocate the remaining slots between
+  // both families by estimated payload before constructing any new tasks.
+  const outstandingProjects = state.projects.filter(
+    (project) => !manifest.tasks.some((item) => item.projectKeys?.includes(project.key)),
+  )
+  const outstandingRootKeys = new Set(state.unknown.map((item) => item.rootKey))
+  for (const entry of manifest.tasks)
+    for (const key of entry.rootKeys ?? []) outstandingRootKeys.delete(key)
+  const outstandingRoots = state.unknown.filter((item) => outstandingRootKeys.has(item.rootKey))
+  const targetSlots = Math.min(availableSlots, outstandingProjects.length + outstandingRoots.length)
+  const projectBaseCost = taskTokens(directory, 'projects-estimate', projectInstruction, {
+    projects: [],
+  })
+  const rootBaseCost = taskTokens(
+    directory,
+    'roots-estimate',
+    classifyInstruction,
+    { knownProjects, families: [] },
+    formatRoots,
+  )
+  const projectCosts = new Map(
+    outstandingProjects.map((project) => [
+      project.key,
+      Math.max(
+        1,
+        taskTokens(directory, 'projects-estimate', projectInstruction, {
+          projects: [
+            {
+              projectId: project.projectId,
+              projectName: project.projectName,
+              workspaceCount: project.metadata.workspaceIds.length,
+              titles: project.metadata.titles,
+            },
+          ],
+        }) - projectBaseCost,
+      ),
+    ]),
+  )
+  const rootCosts = new Map(
+    outstandingRoots.map((root) => [
+      root.rootKey,
+      Math.max(
+        1,
+        taskTokens(
+          directory,
+          'roots-estimate',
+          classifyInstruction,
+          { knownProjects, families: [root] },
+          formatRoots,
+        ) - rootBaseCost,
+      ),
+    ]),
+  )
+  const projectCost = (project) => projectCosts.get(project.key) ?? 1
+  const rootCost = (root) => rootCosts.get(root.rootKey) ?? 1
+  const projectTotal = outstandingProjects.reduce((sum, item) => sum + projectCost(item), 0)
+  const rootTotal = outstandingRoots.reduce((sum, item) => sum + rootCost(item), 0)
+  let projectSlots = 0
+  let rootSlots = 0
+  if (targetSlots === 1) {
+    if (projectTotal >= rootTotal) projectSlots = 1
+    else rootSlots = 1
+  } else if (targetSlots > 1) {
+    if (outstandingProjects.length && outstandingRoots.length) {
+      projectSlots = Math.max(
+        1,
+        Math.min(
+          outstandingProjects.length,
+          Math.round((targetSlots * projectTotal) / (projectTotal + rootTotal)),
+        ),
+      )
+      rootSlots = targetSlots - projectSlots
+      if (rootSlots < 1) {
+        rootSlots = 1
+        projectSlots -= 1
+      }
+      if (rootSlots > outstandingRoots.length) {
+        projectSlots += rootSlots - outstandingRoots.length
+        rootSlots = outstandingRoots.length
+      }
+      if (projectSlots > outstandingProjects.length) {
+        rootSlots += projectSlots - outstandingProjects.length
+        projectSlots = outstandingProjects.length
+      }
+    } else if (outstandingProjects.length) projectSlots = targetSlots
+    else rootSlots = targetSlots
+  }
+
+  const makeProjectTasks = async () => {
+    const queue = [...outstandingProjects]
+    for (let slot = 0; slot < projectSlots && queue.length; slot += 1) {
+      const slotsLeft = projectSlots - slot
+      const maxItems = Math.max(1, queue.length - slotsLeft + 1)
+      const slotBudget = Math.ceil(
+        queue.reduce((sum, item) => sum + projectCost(item), 0) / slotsLeft,
+      )
+      const projects = []
+      let payload = 0
+      while (queue.length) {
+        if (projects.length >= maxItems) break
+        const candidate = queue[0]
+        const projectInput = {
+          projectId: candidate.projectId,
+          projectName: candidate.projectName,
+          workspaceCount: candidate.metadata.workspaceIds.length,
+          titles: candidate.metadata.titles,
+        }
+        const candidateInput = { projects: [...projects, projectInput] }
+        const cost = taskTokens(
+          directory,
+          `projects-${manifest.tasks.length}`,
+          projectInstruction,
+          candidateInput,
+        )
+        if (projects.length && (cost > budget || payload >= slotBudget)) break
+        if (!projects.length && cost > budget) throw new Error('CLASSIFICATION_PROJECT_TOO_LARGE')
+        projects.push(projectInput)
+        payload += projectCost(candidate)
+        queue.shift()
+      }
+      if (!projects.length) break
+      const keys = projects.map((item) => queueProjectKey(state.projects, item.projectId))
+      const item = await task(directory, `projects-${manifest.tasks.length}`, projectInstruction, {
+        projects,
+      })
+      const assigned = { ...item, projectKeys: keys }
+      manifest.tasks.push(assigned)
+      created.push(assigned)
+      await save(join(directory, 'manifest.json'), manifest)
+    }
+  }
+
+  const makeRootTasks = async () => {
+    const rootWorkByKey = new Map(state.roots.map((root) => [root.key, root.workId]))
+    const queue = outstandingRoots
+      .map((root, index) => ({ root, index }))
+      .sort(
+        (a, b) =>
+          String(rootWorkByKey.get(a.root.rootKey)).localeCompare(
+            String(rootWorkByKey.get(b.root.rootKey)),
+          ) || a.index - b.index,
+      )
+      .map(({ root }) => root)
+    for (let slot = 0; slot < rootSlots && queue.length; slot += 1) {
+      const slotsLeft = rootSlots - slot
+      const maxItems = Math.max(1, queue.length - slotsLeft + 1)
+      const slotBudget = Math.ceil(queue.reduce((sum, item) => sum + rootCost(item), 0) / slotsLeft)
+      const batch = []
+      let payload = 0
+      while (queue.length) {
+        if (batch.length >= maxItems) break
+        const candidate = [...batch, queue[0]]
+        const cost = taskTokens(
+          directory,
+          `roots-${manifest.tasks.length}`,
+          classifyInstruction,
+          { knownProjects, families: candidate },
+          formatRoots,
+        )
+        if (batch.length && (cost > budget || payload >= slotBudget)) break
+        if (!batch.length && cost > budget) throw new Error('CLASSIFICATION_ROOT_TOO_LARGE')
+        const root = queue.shift()
+        batch.push(root)
+        payload += rootCost(root)
+      }
+      if (!batch.length) break
+      const item = await task(
+        directory,
+        `roots-${manifest.tasks.length}`,
+        classifyInstruction,
+        { knownProjects, families: batch },
+        formatRoots,
+      )
+      const assigned = { ...item, rootKeys: batch.map((root) => root.rootKey), evidenceRound: 0 }
+      manifest.tasks.push(assigned)
+      created.push(assigned)
+      await save(join(directory, 'manifest.json'), manifest)
+    }
+  }
+
+  const queueProjectKey = (projects, projectId) =>
+    projects.find((item) => item.projectId === projectId)?.key
+  await makeProjectTasks()
+  await makeRootTasks()
+  const assignedRootKeys = new Set(manifest.tasks.flatMap((item) => item.rootKeys ?? []))
+  state.complete =
+    state.projects.every((project) =>
+      manifest.tasks.some((item) => item.projectKeys?.includes(project.key)),
+    ) && state.unknown.every((root) => assignedRootKeys.has(root.rootKey))
+  await save(join(directory, 'manifest.json'), manifest)
+  const tasks = await pendingTasks(manifest)
+  const now = Date.now()
+  const stalled = []
+  for (const item of tasks) {
+    const ageMs = now - (await stat(item.path)).mtimeMs
+    if (ageMs > STALLED_MS) stalled.push({ id: item.id, ageMs: Math.round(ageMs) })
+  }
+  return {
+    stage: 'classification',
+    tasks,
+    ...(stalled.length ? { stalled } : {}),
+    created: created.length,
+    ...(await classificationProgress(manifest)),
+  }
+}

package/skills/tacitt/scripts/journey-classification-validation.d.mts

@@ -0,0 +1,20 @@
+export function validateClassificationJudgment(value: unknown, key: string): void
+export function validateClassificationProject(value: unknown, projectId: string): void
+export function compileAssignments(
+  candidates: Array<{
+    key: string
+    projectName: string
+    roots: Array<[string, string, string] | [string, string, string, string]>
+  }>,
+  assignments: Record<string, string>,
+  overrides?: Array<{ rootKey: string; groupId: string }>,
+): Map<string, string>
+export function validateConsolidationAnswer(
+  answer: unknown,
+  descriptor: {
+    candidates: Array<{
+      roots: Array<[string, string, string] | [string, string, string, string]>
+    }>
+    projectCatalog: unknown[]
+  },
+): { code: string | null; details: string[] }