@gitroll/tacitt-cli 0.0.0-stage → 0.2.0

package/skills/tacitt/scripts/journey-consolidation.mjs

@@ -0,0 +1,227 @@
+import { join } from 'node:path'
+import { readFile } from 'node:fs/promises'
+import { randomUUID } from 'node:crypto'
+import { optional, save } from './journey-state.mjs'
+import { answers, task, taskTokens } from './journey-tasks.mjs'
+import {
+  validateClassificationJudgment,
+  validateClassificationProject,
+} from './journey-classification-validation.mjs'
+import { createMetadataTasks } from './journey-classification-metadata.mjs'
+
+const budget = 90000
+const instruction =
+  'You own the semantic audit and reconciliation of every supplied candidate/root; Main only dispatches this generated task and runs CLI validation/ingestion. Read every task range, including all root intents, evidence and context, then author and publish the complete answer yourself. Reconcile candidate buckets globally into final Works, not one final group per input bucket. Input size is not output size: provide only a compact group catalog and one explicit candidate-key-to-group-ID assignment for every candidate. Before proposing a new project, topic or Unsorted, compare every candidate/root against every entry in catalog. Merge equivalent supported identities across differently named candidates and attach proven existing projects using the exact catalog targetProjectId. A root with a targetProjectId has a fixed identity constraint: it must finish in a group with that same targetProjectId, including after overrides; do not redirect it or erase that target. Other roots may be attached to its group when supported. Assign miscellaneous candidates to one Unsorted; retain a topic only when at least three roots genuinely share it. Return ONLY {groups:[{id,projectName,groupKind,targetProjectId?}],assignments:{candidateKey:groupId,...},overrides?:[{rootKey,groupId}]}. Assignment keys must be the exact supplied candidate.key strings; include each exactly once and no other keys. Do not use positional arrays. Do not include description, projectType, recommendation, privacy rationale or other fields. An assignment initially applies to every root in that candidate; overrides split homonyms or path conflicts but cannot violate an existing targetProjectId constraint. Do not merge identities merely because names match. Every supplied root must end in exactly one group. Do not include root keys in groups or invent identities. Known projects attach with exact targetProjectId. The rootContext rows include CLI facts and bounded partial projectEvidence. Partial references are positive evidence, not completeness proof; missing evidence is not negative proof. Checking, using, connecting to, or integrating with a product/tool does not prove that a root develops that product’s repository; require independent repository or content evidence before assigning product project identity. A product topic may remain when roots genuinely share it. A scratch workspace name alone is not project evidence, even if descriptive; however do not ignore exact repository references or independent content evidence. Reject unsupported project or topic claims in workIntent or groupingBasis that merely reinterpret a generated scratch/temp name or copy a sibling’s activity. Missing root-specific intent must remain unknown; a coherent topic requires positive evidence for that root’s membership, otherwise use Unsorted. Do not turn an uncertain initial guess into evidence by repeating it. Before publishing, audit every candidate with workspaceKind folder separately from scratch/temp: a supported named ordinary-folder project is groupKind project, including a singleton; lack of Git metadata does not downgrade it to topic or Unsorted. The known catalog is not exhaustive. Before assigning Unsorted, audit every root with repository references, changes, or an ordinary named folder, together with its sibling roots: an independently evidenced new repository can form its own project even with one root. Missing catalog membership is not negative evidence. Before publishing, compare every retained new group with known project aliases and product-specific task intent so connection checks and supporting work are not split from their supported parent project. Do not use repository reference counts, change counts or apparent dominance as a majority vote for genuinely cross-project roots. Ambiguous or incomplete cross-project evidence needs direct owning intent before adding a targetProjectId; otherwise preserve uncertainty and leave the root unbound. Existing fixed targets remain binding; do not invent corroboration for them. Keep clear projects independent. CLI combines topics with fewer than three final roots and miscellaneous roots into Unsorted. Preserve clear projects with one root. Do not omit roots or force unrelated roots into themes. Names <=240 chars. This is a proposal, never approval.'
+
+function dispatchDescriptor(item) {
+  return {
+    id: item.id,
+    path: item.path,
+    answer: item.answer,
+    descriptor: item.descriptor,
+    prompt: item.prompt,
+    inputHash: item.inputHash,
+  }
+}
+
+const formatPayload = (data) => {
+  const candidates = data.candidates.map(
+    (candidate) =>
+      `{${Object.entries(candidate)
+        .map(
+          ([key, value]) =>
+            `${JSON.stringify(key)}:${key === 'roots' ? `[\n${value.map((row) => JSON.stringify(row)).join(',\n')}\n]` : JSON.stringify(value)}`,
+        )
+        .join(',')}}`,
+  )
+  return `{"catalog":${JSON.stringify(data.catalog)},"rootContext":[\n${data.rootContext.map((row) => JSON.stringify(row)).join(',\n')}\n],"candidates":[\n${candidates.join(',\n')}\n]}`
+}
+
+async function latestJudgments(manifest) {
+  const latest = new Map()
+  const pendingProjectTasks = []
+  for (const item of manifest.tasks) {
+    if (item.projectKeys) {
+      if (!(await optional(item.answer))) {
+        pendingProjectTasks.push(item)
+        continue
+      }
+      const results = await answers([item], 'items')
+      const ids = results.map((result) => result.projectId)
+      if (ids.length !== item.projectKeys.length || new Set(ids).size !== ids.length)
+        throw new Error('PROJECT_METADATA_COVERAGE_INVALID')
+      const expected = item.projectKeys.map(
+        (key) => manifest.classification.projects.find((project) => project.key === key)?.projectId,
+      )
+      if (expected.some((id) => !id) || expected.some((id) => !ids.includes(id)))
+        throw new Error('PROJECT_METADATA_COVERAGE_INVALID')
+      for (const result of results) {
+        if (
+          !item.projectKeys.includes(
+            manifest.classification.projects.find(
+              (project) => project.projectId === result.projectId,
+            )?.key,
+          )
+        )
+          throw new Error('PROJECT_METADATA_COVERAGE_INVALID')
+        validateClassificationProject(result, result.projectId)
+      }
+      continue
+    }
+    if (!(await optional(item.answer))) continue
+    const results = await answers([item], 'judgments')
+    const value = JSON.parse(await readFile(item.answer, 'utf8'))
+    const requested = value.evidenceRootKeys ?? []
+    if (!Array.isArray(requested) || requested.some((key) => !item.rootKeys.includes(key)))
+      throw new Error('INVALID_EVIDENCE_ROOTS')
+    if (item.evidenceRound > 0 && requested.length) throw new Error('EVIDENCE_ESCALATION_LIMIT')
+    const seen = new Set()
+    for (const result of results) {
+      if (!item.rootKeys.includes(result.rootKey) || seen.has(result.rootKey))
+        throw new Error('CLASSIFICATION_JUDGMENT_COVERAGE_INVALID')
+      validateClassificationJudgment(result, result.rootKey)
+      if (
+        result.targetProjectId &&
+        !manifest.classification.projects.some(
+          (project) => project.projectId === result.targetProjectId,
+        )
+      )
+        throw new Error('UNKNOWN_TARGET_PROJECT')
+      seen.add(result.rootKey)
+      latest.set(result.rootKey, result)
+    }
+    if (seen.size !== item.rootKeys.length)
+      throw new Error('CLASSIFICATION_JUDGMENT_COVERAGE_INVALID')
+  }
+  return { latest, pendingProjectTasks }
+}
+
+export async function consolidateClassification(directory, manifest, { refresh = false } = {}) {
+  if (!manifest.classification?.complete) throw new Error('CLASSIFICATION_READS_INCOMPLETE')
+  const { latest, pendingProjectTasks } = await latestJudgments(manifest)
+  const unknownKeys = manifest.classification.unknown.map((item) => item.rootKey)
+  if (unknownKeys.some((key) => !latest.has(key)))
+    throw new Error('CLASSIFICATION_ANSWERS_INCOMPLETE')
+  if (refresh && (!manifest.consolidation || manifest.consolidation.automatic))
+    throw new Error('CLASSIFICATION_REFRESH_UNAVAILABLE')
+  if (unknownKeys.length === 0) {
+    manifest.consolidation = {
+      automatic: true,
+      answer: null,
+      candidates: [],
+      projectCatalog: manifest.classification.projects.map((project) => ({
+        projectId: project.projectId,
+        projectName: project.projectName,
+      })),
+    }
+    await save(join(directory, 'manifest.json'), manifest)
+    return {
+      stage: 'classification',
+      consolidationReady: true,
+      readyForIngest: pendingProjectTasks.length === 0,
+      automatic: true,
+      tasks: pendingProjectTasks,
+    }
+  }
+  if (manifest.consolidation) {
+    if (refresh && manifest.consolidation.automatic)
+      throw new Error('CLASSIFICATION_REFRESH_UNAVAILABLE')
+    if (refresh) {
+      manifest.consolidationHistory ??= []
+      manifest.consolidationHistory.push({
+        ...manifest.consolidation,
+        supersededAt: new Date().toISOString(),
+      })
+    } else {
+      if (manifest.consolidation.automatic)
+        return {
+          stage: 'classification',
+          consolidationReady: true,
+          readyForIngest: pendingProjectTasks.length === 0,
+          automatic: true,
+          tasks: pendingProjectTasks,
+        }
+      if (!(await optional(manifest.consolidation.answer)))
+        return {
+          stage: 'classification',
+          consolidationReady: true,
+          readyForIngest: false,
+          tasks: [dispatchDescriptor(manifest.consolidation)],
+        }
+      const result = await createMetadataTasks(directory, manifest)
+      const tasks = [...pendingProjectTasks, ...result.tasks]
+      return {
+        ...result,
+        readyForIngest: result.readyForIngest && pendingProjectTasks.length === 0,
+        tasks,
+      }
+    }
+  }
+  const roots = unknownKeys.map((rootKey) => {
+    const judgment = latest.get(rootKey)
+    validateClassificationJudgment(judgment, rootKey)
+    return {
+      rootKey,
+      projectName: judgment.projectName,
+      workIntent: judgment.workIntent,
+      groupingBasis: judgment.groupingBasis,
+      ...(judgment.targetProjectId ? { targetProjectId: judgment.targetProjectId } : {}),
+    }
+  })
+  const candidatesByName = new Map()
+  for (const root of roots) {
+    const projectName = root.projectName.trim().normalize('NFC')
+    const name = projectName.toLocaleLowerCase('en-US')
+    const identity = JSON.stringify([root.targetProjectId ?? null, name])
+    let candidate = candidatesByName.get(identity)
+    if (!candidate) {
+      candidate = {
+        key: `c${candidatesByName.size + 1}`,
+        projectName,
+        ...(root.targetProjectId ? { targetProjectId: root.targetProjectId } : {}),
+        roots: [],
+      }
+      candidatesByName.set(identity, candidate)
+    }
+    candidate.roots.push([
+      root.rootKey,
+      root.workIntent,
+      root.groupingBasis,
+      ...(root.targetProjectId ? [root.targetProjectId] : []),
+    ])
+  }
+  const catalog = manifest.classification.projects.map((project) => ({
+    projectId: project.projectId,
+    projectName: project.projectName,
+  }))
+  const candidates = [...candidatesByName.values()]
+  const rootContext = manifest.classification.unknown.map((root) => [
+    root.rootKey,
+    root.metadata?.workspaceKind ?? null,
+    root.metadata?.workspaceName ?? null,
+    root.metadata?.projectEvidence ?? null,
+  ])
+  const data = { catalog, rootContext, candidates }
+  if (taskTokens(directory, 'consolidation', instruction, data, formatPayload) > budget)
+    throw new Error('CLASSIFICATION_CONSOLIDATION_TOO_LARGE')
+  const consolidationId = refresh ? `consolidation-${randomUUID()}` : 'consolidation'
+  manifest.consolidation = await task(directory, consolidationId, instruction, data, formatPayload)
+  const descriptor = JSON.parse(await readFile(manifest.consolidation.descriptor, 'utf8'))
+  descriptor.candidates = candidates
+  descriptor.projectCatalog = catalog
+  await save(manifest.consolidation.descriptor, descriptor)
+  manifest.consolidation.candidates = candidates
+  manifest.consolidation.projectCatalog = catalog
+  await save(join(directory, 'manifest.json'), manifest)
+  return {
+    stage: 'classification',
+    consolidationReady: true,
+    readyForIngest: false,
+    tasks: [dispatchDescriptor(manifest.consolidation)],
+  }
+}
+
+export {
+  classificationSubmission,
+  partialClassificationSubmission,
+} from './journey-consolidation-submit.mjs'

package/skills/tacitt/scripts/journey-scan-timing.mjs

@@ -0,0 +1,143 @@
+import { join } from 'node:path'
+import { hash, optional, save } from './journey-state.mjs'
+
+const selected = (view) =>
+  view.works.filter((work) => work.access !== 'drop' && work.rootSessionIds.length)
+
+function layout(view) {
+  return view.works
+    .map((work) => ({
+      id: work.id,
+      inputRevision: work.inputRevision,
+      access: work.access,
+      roots: [...work.rootSessionIds].sort((a, b) => a.localeCompare(b)),
+    }))
+    .sort((a, b) => a.id.localeCompare(b.id))
+}
+
+function binding(view, journeyId) {
+  const roots = view.works
+    .flatMap((work) => work.rootSessionIds.map((id) => [id, work.access]))
+    .sort((a, b) => a[0].localeCompare(b[0]))
+  if (new Set(roots.map(([id]) => id)).size !== roots.length)
+    throw new Error('SCAN_TIMING_DUPLICATE_ROOT')
+  return hash({
+    journeyId,
+    snapshotId: view.snapshotId,
+    classificationRevision: view.classificationRevision,
+    configurationId: view.configurationId,
+    roots,
+  })
+}
+
+function complete(view) {
+  if (
+    !view.consent ||
+    view.scope.status !== 'confirmed' ||
+    !view.readingComplete ||
+    view.phase === 'paused'
+  )
+    return false
+  if (
+    selected(view).some(
+      (work) => ['pending', 'blocked'].includes(work.status) || !work.classificationMetadata,
+    )
+  )
+    return false
+  const pending = view.privacy.terms
+    .filter((term) => term.disposition === 'pending')
+    .map((term) => JSON.stringify([term.type, term.value.normalize('NFC')]))
+  if (!pending.length) return true
+  const cards = view.privacy.cards
+  if (!cards.length || cards.length > 20) return false
+  const covered = cards.flatMap((card) => card.termKeys)
+  return (
+    covered.length === pending.length &&
+    new Set(covered).size === covered.length &&
+    pending.every((key) => covered.includes(key))
+  )
+}
+
+/** Observe the complete static + AI + metadata + cards wall interval without owning preparation. */
+export async function scanTiming(run, journeyId, view, start = false, call) {
+  const path = join(run, 'scan-timing.json')
+  let receipt = await optional(path)
+  const identity = binding(view, journeyId)
+  if (!receipt && !start) return null
+  const guidance = !receipt?.completedAt
+    ? (await call('review.guidance', { journeyId })).guidance
+    : null
+  const authority = guidance
+    ? hash({
+        instructions: guidance.instructions,
+        valueOverrides: guidance.valueOverrides,
+        rules: guidance.rules,
+        conditions: guidance.conditions.filter((condition) =>
+          ['explicit', 'delegate', 'preference'].includes(condition.origin),
+        ),
+      })
+    : null
+  if (!receipt) {
+    if (
+      !view.consent ||
+      !view.snapshotId ||
+      view.classificationRevision === null ||
+      view.scope.status !== 'confirmed' ||
+      view.phase === 'paused' ||
+      !selected(view).length
+    )
+      throw new Error('SCAN_TIMING_NOT_ALLOWED')
+    if (
+      view.readingComplete ||
+      view.privacy.terms.length ||
+      view.privacy.cards.length ||
+      view.works.some(
+        (work) =>
+          work.status !== 'pending' ||
+          work.totalBatches ||
+          work.completedBatches ||
+          work.emptyReview ||
+          work.classificationMetadata ||
+          work.metadataReviewedDigest ||
+          work.artifact,
+      )
+    )
+      throw new Error('SCAN_TIMING_ALREADY_PREPARED')
+    receipt = {
+      binding: identity,
+      authority,
+      initialGuidanceDigest: view.guidanceDigest,
+      startedAt: new Date().toISOString(),
+      completedAt: null,
+      startRevision: view.revision,
+      snapshotId: view.snapshotId,
+      initialWorks: layout(view),
+    }
+    await save(path, receipt)
+  }
+  if (receipt.binding !== identity || (authority !== null && receipt.authority !== authority))
+    throw new Error('SCAN_TIMING_SCOPE_CHANGED')
+  if (!receipt.completedAt && complete(view)) {
+    receipt = {
+      ...receipt,
+      completedAt: new Date().toISOString(),
+      endRevision: view.revision,
+      finalWorks: layout(view),
+      finalGuidanceDigest: view.guidanceDigest,
+    }
+    await save(path, receipt)
+  }
+  const elapsedMs =
+    Date.parse(receipt.completedAt ?? new Date().toISOString()) - Date.parse(receipt.startedAt)
+  const { initialWorks, finalWorks, ...summary } = receipt
+  return {
+    ...summary,
+    initialWorkCount: initialWorks.length,
+    ...(finalWorks ? { finalWorkCount: finalWorks.length } : {}),
+    receipt: path,
+    status: receipt.completedAt ? 'complete' : 'running',
+    elapsedMs,
+    budgetMs: 30 * 60 * 1000,
+    withinBudget: receipt.completedAt ? elapsedMs < 30 * 60 * 1000 : null,
+  }
+}

package/skills/tacitt/scripts/journey-state.d.mts

@@ -0,0 +1,43 @@
+export function save(path: string, value: unknown): Promise<void>
+export function cardBatchOpen(run: string): Promise<boolean>
+export function hash(value: unknown): string
+export function definiteWriteRejection(error: unknown): boolean
+export function stageFingerprint(view: unknown, stage: string): string
+export function planResolutions(
+  view: {
+    works: {
+      access: string
+      rootSessionIds: string[]
+      projectName?: string
+      classificationMetadata?: { projectName?: string }
+    }[]
+    privacy: {
+      terms: { type: string; value: string; disposition: string }[]
+      cards?: { termKeys: string[]; answer?: { optionId: string } | null }[]
+    }
+    valueOverrides?: { value: string; choice: 'hide' | 'keep' }[]
+  },
+  resolutions: {
+    type: string
+    value: string
+    disposition: 'hidden' | 'keep'
+    reason: string
+  }[],
+): {
+  id: string
+  resolutions: { type: string; value: string; disposition: 'hidden' | 'keep'; reason: string }[]
+}[]
+export function recoverWrites(
+  directory: string,
+  manifest: { stage: string; tasks?: { id: string }[]; resolutionBatches?: { id: string }[] },
+  call: (
+    procedure: string,
+    request: unknown,
+  ) => Promise<{ status: string; state?: { revision: number } }>,
+): Promise<{
+  recovered: number
+  completed: number
+  total: number
+  stale: boolean
+  rejected: string | null
+}>