theslopmachine 0.3.7 → 0.4.0

package/src/constants.js

@@ -2,9 +2,9 @@ import os from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
-export const PACKAGE_VERSION = '0.3.7'
+export const PACKAGE_VERSION = '0.4.0'
 export const OPCODE_VERSION = '1.3.5'
-export const BEADS_VERSION = '0.52.0'
+export const BR_VERSION = '0.1.34'
 export const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
 
 export function resolveHomeDir() {
@@ -25,13 +25,30 @@ export function buildPaths() {
 
 export const REQUIRED_SKILL_DIRS = [
   'clarification-gate',
+  'clarification-gate-v2',
   'developer-session-lifecycle',
+  'developer-session-lifecycle-v2',
+  'session-rollover-v2',
   'final-evaluation-orchestration',
+  'final-evaluation-orchestration-v2',
   'beads-operations',
+  'beads-operations-v2',
   'get-overlays',
+  'planning-guidance-v2',
   'planning-gate',
+  'planning-gate-v2',
+  'scaffold-guidance-v2',
+  'development-guidance-v2',
   'verification-gates',
+  'verification-gates-v2',
+  'integrated-verification-v2',
+  'hardening-gate-v2',
+  'evaluation-triage-v2',
+  'remediation-guidance-v2',
   'submission-packaging',
+  'submission-packaging-v2',
+  'owner-evidence-discipline-v2',
+  'report-output-discipline-v2',
   'frontend-design',
 ]
 
@@ -42,8 +59,10 @@ export const REQUIRED_SLOPMACHINE_FILES = [
   'quality-document.md',
   'engineering-results.md',
   'implementation-comparison.md',
-  'beads-init.js',
+  'tracker-init.js',
+  'workflow-init-v2.js',
   'templates/AGENTS.md',
+  'templates/AGENTS-v2.md',
   'utils/strip_session_parent.py',
   'utils/convert_ai_session.py',
 ]

package/src/init.js

@@ -21,33 +21,33 @@ const GITIGNORE_ENTRIES = [
   'antigravity-logs/',
 ]
 
-function getUnixBeadsCommandCandidates(paths) {
+function getUnixTrackerCommandCandidates(paths) {
   return [
-    path.join(paths.home, '.local', 'bin', 'bd'),
-    path.join(paths.home, '.linuxbrew', 'bin', 'bd'),
-    '/opt/homebrew/bin/bd',
-    '/usr/local/bin/bd',
-    '/home/linuxbrew/.linuxbrew/bin/bd',
+    path.join(paths.home, '.local', 'bin', 'br'),
+    path.join(paths.home, '.cargo', 'bin', 'br'),
+    '/opt/homebrew/bin/br',
+    '/usr/local/bin/br',
   ]
 }
 
-function getWindowsBeadsCommandCandidates() {
+function getWindowsTrackerCommandCandidates(paths) {
   if (process.platform !== 'win32') {
     return []
   }
 
   return [
-    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Programs', 'bd', 'bd.exe') : null,
-    process.env.USERPROFILE ? path.join(process.env.USERPROFILE, 'go', 'bin', 'bd.exe') : null,
+    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Programs', 'br', 'br.exe') : null,
+    path.join(paths.home, '.local', 'bin', 'br.exe'),
+    path.join(paths.home, '.cargo', 'bin', 'br.exe'),
   ].filter(Boolean)
 }
 
-async function resolveBeadsCommand(paths) {
+async function resolveTrackerCommand(paths) {
   const candidates = process.platform === 'win32'
-    ? getWindowsBeadsCommandCandidates()
-    : getUnixBeadsCommandCandidates(paths)
+    ? getWindowsTrackerCommandCandidates(paths)
+    : getUnixTrackerCommandCandidates(paths)
 
-  return resolveCommand('bd', { additionalCandidates: candidates, preferCandidates: true })
+  return resolveCommand('br', { additionalCandidates: candidates, preferCandidates: true })
 }
 
 function parseInitArgs(args) {
@@ -71,18 +71,23 @@ function parseInitArgs(args) {
 }
 
 async function assertRequiredFiles(paths) {
-  const beadsScript = path.join(paths.slopmachineDir, 'beads-init.js')
+  const workflowInitV2 = path.join(paths.slopmachineDir, 'workflow-init-v2.js')
+  const trackerScript = path.join(paths.slopmachineDir, 'tracker-init.js')
+  const agentsTemplateV2 = path.join(paths.slopmachineDir, 'templates', 'AGENTS-v2.md')
   const agentsTemplate = path.join(paths.slopmachineDir, 'templates', 'AGENTS.md')
 
-  if (!(await pathExists(beadsScript))) {
-    throw new Error(`Missing packaged Beads init script at ${beadsScript}. Run slopmachine setup first.`)
+  const bootstrapScript = await pathExists(workflowInitV2) ? workflowInitV2 : trackerScript
+  const selectedAgentsTemplate = await pathExists(agentsTemplateV2) ? agentsTemplateV2 : agentsTemplate
+
+  if (!(await pathExists(bootstrapScript))) {
+    throw new Error(`Missing packaged workflow init script at ${bootstrapScript}. Run slopmachine setup first.`)
   }
 
-  if (!(await pathExists(agentsTemplate))) {
-    throw new Error(`Missing packaged AGENTS template at ${agentsTemplate}. Run slopmachine setup first.`)
+  if (!(await pathExists(selectedAgentsTemplate))) {
+    throw new Error(`Missing packaged AGENTS template at ${selectedAgentsTemplate}. Run slopmachine setup first.`)
   }
 
-  return { beadsScript, agentsTemplate }
+  return { trackerScript: bootstrapScript, agentsTemplate: selectedAgentsTemplate }
 }
 
 async function resolveTarget(targetInput) {
@@ -127,25 +132,25 @@ async function ensureGitignore(targetPath) {
   }
 }
 
-async function runBeadsBootstrap(paths, targetPath, beadsScript) {
+async function runTrackerBootstrap(paths, targetPath, trackerScript) {
   const nodeExecutable = process.execPath
   if (!nodeExecutable) {
-    throw new Error('Unable to locate the current Node.js executable for Beads bootstrap.')
+    throw new Error('Unable to locate the current Node.js executable for workflow bootstrap.')
   }
 
-  const beadsCommand = await resolveBeadsCommand(paths)
+  const trackerCommand = await resolveTrackerCommand(paths)
 
-  log('Running Beads setup')
-  const result = await runCommand(nodeExecutable, [beadsScript, targetPath], {
+  log('Running workflow bootstrap')
+  const result = await runCommand(nodeExecutable, [trackerScript, targetPath], {
     stdio: 'inherit',
     env: {
       ...process.env,
-      BD_COMMAND: beadsCommand || '',
+      BR_COMMAND: trackerCommand || '',
       HOME: paths.home,
     },
   })
   if (result.code !== 0) {
-    throw new Error('Beads initialization failed')
+    throw new Error('Tracker initialization failed')
   }
 }
 
@@ -196,7 +201,7 @@ async function maybeOpenOpencode(targetPath, openAfterInit) {
 export async function runInit(args = []) {
   const paths = buildPaths()
   const { openAfterInit, targetInput } = parseInitArgs(args)
-  const { beadsScript, agentsTemplate } = await assertRequiredFiles(paths)
+  const { trackerScript, agentsTemplate } = await assertRequiredFiles(paths)
   const targetPath = await resolveTarget(targetInput)
 
   log(`Target: ${targetPath}`)
@@ -206,7 +211,7 @@ export async function runInit(args = []) {
   await ensureGitRepo(targetPath)
   log('Ensuring .gitignore defaults')
   await ensureGitignore(targetPath)
-  await runBeadsBootstrap(paths, targetPath, beadsScript)
+  await runTrackerBootstrap(paths, targetPath, trackerScript)
   await createRepoStructure(targetPath, agentsTemplate)
   await createInitialCommit(targetPath)
   await maybeOpenOpencode(targetPath, openAfterInit)