idlewatch 0.1.0

package/scripts/validate-openclaw-stats-ingestion.mjs

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, chmodSync, rmSync } from 'node:fs'
+import { readTelemetryJsonRow } from './lib/telemetry-row-parser.mjs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { execFileSync } from 'node:child_process'
+
+const repoRoot = process.cwd()
+const tempDir = mkdtempSync(join(tmpdir(), 'idlewatch-openclaw-stats-egress-'))
+const mockBinPath = join(tempDir, 'openclaw-mock.sh')
+
+function writeMockOpenClaw(pathToScript, shape) {
+  const resultCurrent = `{
+  "status": {
+    "result": {
+      "stats": {
+        "current": {
+          "session": {
+            "sessionId": "mock-stats-session",
+            "agentId": "agent-stats-mock",
+            "model": "gpt-5.3-codex",
+            "totalTokens": 6789,
+            "tokensPerMinute": 33.25,
+            "updatedAt": 1771304100000
+          }
+        }
+      }
+    }
+  },
+  "ts": 1771304200000
+}`
+
+  const statusCurrent = `{
+  "status": {
+    "current": {
+      "stats": {
+        "current": {
+          "session": {
+            "sessionId": "status-current-session",
+            "agentId": "agent-stats-status-current",
+            "model": "gpt-5.3-codex-pro",
+            "totalTokens": 2048,
+            "tokensPerMinute": 42,
+            "updatedAt": 1771304500000
+          }
+        }
+      }
+    }
+  },
+  "ts": 1771304600000
+}`
+
+  const statusCurrentTsMs = `{
+  "status": {
+    "current": {
+      "stats": {
+        "current": {
+          "session": {
+            "sessionId": "status-current-ts-ms",
+            "agentId": "agent-stats-ts-ms",
+            "model": "gpt-5.3-codex",
+            "totalTokens": 4096,
+            "tokensPerMinute": 64,
+            "usage_ts_ms": 1771306600000
+          }
+        }
+      }
+    }
+  },
+  "ts": 1771306700000
+}`
+
+  const statusCurrentUsageTs = `{
+  "status": {
+    "current": {
+      "stats": {
+        "current": {
+          "session": {
+            "sessionId": "status-current-usage-ts",
+            "agentId": "agent-stats-usage-ts",
+            "model": "gpt-5.3-codex",
+            "totalTokens": 4096,
+            "tokensPerMinute": 64,
+            "usage_ts": 1771307000000
+          }
+        }
+      }
+    }
+  },
+  "ts": 1771307100000
+}
+`
+
+  const statusCurrentUsageTimestampMs = `{
+  "status": {
+    "current": {
+      "stats": {
+        "current": {
+          "session": {
+            "sessionId": "status-current-usage-ts-ms",
+            "agentId": "agent-stats-usage-ts-ms",
+            "model": "qwen3",
+            "totalTokens": 512,
+            "tokensPerMinute": 16,
+            "usage_timestamp_ms": 1771308800000
+          }
+        }
+      }
+    }
+  },
+  "ts": 1771308900000
+}`
+
+  const statusCurrentUpdatedAtMs = `{
+  "status": {
+    "current": {
+      "stats": {
+        "current": {
+          "session": {
+            "sessionId": "status-current-updated-at-ms",
+            "agentId": "agent-stats-updated-at-ms",
+            "model": "gpt-5.3-codex-pro",
+            "totalTokens": 876,
+            "tokensPerMinute": 11,
+            "updated_at_ms": 1771313300000
+          }
+        }
+      }
+    }
+  },
+  "ts": 1771313400000
+}`
+
+  const statusCurrentUsageTimestamp = `{
+  "status": {
+    "current": {
+      "stats": {
+        "current": {
+          "session": {
+            "sessionId": "status-current-usage-timestamp",
+            "agentId": "agent-stats-usage-timestamp",
+            "model": "qwen-lite",
+            "totalTokens": 3333,
+            "tokensPerMinute": 9.75,
+            "usage_timestamp": "2026-02-27T09:00:00.000Z"
+          }
+        }
+      }
+    }
+  },
+  "ts": 1771319100000
+}`
+
+  const statusCurrentUsageTime = `{
+  "status": {
+    "current": {
+      "stats": {
+        "current": {
+          "session": {
+            "sessionId": "status-current-usage-time",
+            "agentId": "agent-stats-usage-time",
+            "model": "qwen-lite",
+            "totalTokens": 4444,
+            "tokensPerMinute": 8.5,
+            "usage_time": "2026-02-27T10:15:00.000Z"
+          }
+        }
+      }
+    }
+  },
+  "ts": 1771323300000
+}`
+
+  const statusCurrentUsageTimeCamel = `{
+  "status": {
+    "current": {
+      "stats": {
+        "current": {
+          "session": {
+            "sessionId": "status-current-usage-time-camel",
+            "agentId": "agent-stats-usage-time-camel",
+            "model": "qwen-camel",
+            "totalTokens": 5555,
+            "tokensPerMinute": 13.3,
+            "usageTime": "2026-02-27T10:45:00.000Z"
+          }
+        }
+      }
+    }
+  },
+  "ts": 1771324500000
+}`
+
+  const script = `#!/usr/bin/env bash
+set -euo pipefail
+
+SCENARIO="${shape}"
+if [[ "$1" == "usage" || "$1" == "status" || "$1" == "session" || "$1" == "session_status" ]]; then
+  echo '{"message":"legacy status output unavailable"}\n'
+  exit 0
+fi
+
+if [[ "$1" == "stats" ]]; then
+  if [[ "$SCENARIO" == "statusCurrent" ]]; then
+    cat <<JSON
+${statusCurrent}
+JSON
+  elif [[ "$SCENARIO" == "statusCurrentTsMs" ]]; then
+    cat <<JSON
+${statusCurrentTsMs}
+JSON
+  elif [[ "$SCENARIO" == "statusCurrentUsageTs" ]]; then
+    cat <<JSON
+${statusCurrentUsageTs}
+JSON
+  elif [[ "$SCENARIO" == "statusCurrentUsageTimestampMs" ]]; then
+    cat <<JSON
+${statusCurrentUsageTimestampMs}
+JSON
+  elif [[ "$SCENARIO" == "statusCurrentUpdatedAtMs" ]]; then
+    cat <<JSON
+${statusCurrentUpdatedAtMs}
+JSON
+  elif [[ "$SCENARIO" == "statusCurrentUsageTimestamp" ]]; then
+    cat <<JSON
+${statusCurrentUsageTimestamp}
+JSON
+  elif [[ "$SCENARIO" == "statusCurrentUsageTime" ]]; then
+    cat <<JSON
+${statusCurrentUsageTime}
+JSON
+  elif [[ "$SCENARIO" == "statusCurrentUsageTimeCamel" ]]; then
+    cat <<JSON
+${statusCurrentUsageTimeCamel}
+JSON
+  else
+    cat <<JSON
+${resultCurrent}
+JSON
+  fi
+  exit 0
+fi
+
+echo '{"error":"unsupported command"}'
+exit 2
+`
+  writeFileSync(pathToScript, script, 'utf8')
+  chmodSync(pathToScript, 0o755)
+}
+
+function readRow(output) {
+  return readTelemetryJsonRow(output)
+}
+
+function run(shape, expectations) {
+  writeMockOpenClaw(mockBinPath, shape)
+
+  const env = {
+    ...process.env,
+    IDLEWATCH_OPENCLAW_BIN: mockBinPath,
+    IDLEWATCH_OPENCLAW_BIN_STRICT: '1',
+    IDLEWATCH_OPENCLAW_PROBE_RETRIES: '0',
+    IDLEWATCH_USAGE_STALE_MS: '60000',
+    IDLEWATCH_USAGE_STALE_GRACE_MS: '10000',
+    IDLEWATCH_USAGE_REFRESH_REPROBES: '0',
+    IDLEWATCH_INTERVAL_MS: '1000',
+    IDLEWATCH_OPENCLAW_USAGE: 'auto'
+  }
+
+  const out = execFileSync('node', ['bin/idlewatch-agent.js', '--dry-run'], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    env,
+    stdio: ['ignore', 'pipe', 'pipe']
+  })
+
+  const row = readRow(out)
+  assert.equal(row?.source?.usage, 'openclaw', 'usage should be sourced from openclaw when stats fallback is used')
+  assert.equal(row?.source?.usageIngestionStatus, 'ok', 'usage ingestion should remain healthy')
+  assert.equal(row?.source?.usageProbeResult, 'ok', 'stats command should succeed')
+  assert.equal(row?.source?.usageProbeAttempts >= 3, true, 'stats fallback path should have attempted several commands')
+  assert.equal(row?.source?.usageCommand.includes('stats --json'), true, 'stats command should be selected after fallback attempts')
+  assert.equal(row?.openclawSessionId, expectations.sessionId)
+  assert.equal(row?.openclawAgentId, expectations.agentId)
+  assert.equal(row?.openclawTotalTokens, expectations.totalTokens)
+  assert.equal(row?.openclawModel, expectations.model)
+  assert.equal(row?.tokensPerMin, expectations.tokensPerMin)
+  assert.equal(row?.source?.usageProbeError || null, null)
+}
+
+function runAllShapes() {
+  run('resultCurrent', {
+    sessionId: 'mock-stats-session',
+    agentId: 'agent-stats-mock',
+    totalTokens: 6789,
+    model: 'gpt-5.3-codex',
+    tokensPerMin: 33.25
+  })
+
+  run('statusCurrent', {
+    sessionId: 'status-current-session',
+    agentId: 'agent-stats-status-current',
+    totalTokens: 2048,
+    model: 'gpt-5.3-codex-pro',
+    tokensPerMin: 42
+  })
+
+  run('statusCurrentTsMs', {
+    sessionId: 'status-current-ts-ms',
+    agentId: 'agent-stats-ts-ms',
+    totalTokens: 4096,
+    model: 'gpt-5.3-codex',
+    tokensPerMin: 64
+  })
+
+  run('statusCurrentUsageTs', {
+    sessionId: 'status-current-usage-ts',
+    agentId: 'agent-stats-usage-ts',
+    totalTokens: 4096,
+    model: 'gpt-5.3-codex',
+    tokensPerMin: 64
+  })
+
+  run('statusCurrentUsageTimestampMs', {
+    sessionId: 'status-current-usage-ts-ms',
+    agentId: 'agent-stats-usage-ts-ms',
+    totalTokens: 512,
+    model: 'qwen3',
+    tokensPerMin: 16
+  })
+
+  run('statusCurrentUsageTimestamp', {
+    sessionId: 'status-current-usage-timestamp',
+    agentId: 'agent-stats-usage-timestamp',
+    totalTokens: 3333,
+    model: 'qwen-lite',
+    tokensPerMin: 9.75
+  })
+
+  run('statusCurrentUsageTime', {
+    sessionId: 'status-current-usage-time',
+    agentId: 'agent-stats-usage-time',
+    totalTokens: 4444,
+    model: 'qwen-lite',
+    tokensPerMin: 8.5
+  })
+
+  run('statusCurrentUsageTimeCamel', {
+    sessionId: 'status-current-usage-time-camel',
+    agentId: 'agent-stats-usage-time-camel',
+    totalTokens: 5555,
+    model: 'qwen-camel',
+    tokensPerMin: 13.3
+  })
+
+  run('statusCurrentUpdatedAtMs', {
+    sessionId: 'status-current-updated-at-ms',
+    agentId: 'agent-stats-updated-at-ms',
+    totalTokens: 876,
+    model: 'gpt-5.3-codex-pro',
+    tokensPerMin: 11
+  })
+
+  console.log('validate-openclaw-stats-ingestion: ok (stats-only command path parsed and ingested across multiple payload shapes)')
+}
+
+try {
+  runAllShapes()
+} finally {
+  rmSync(tempDir, { recursive: true, force: true })
+}

package/scripts/validate-openclaw-usage-health.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, chmodSync, rmSync } from 'node:fs'
+import { readTelemetryJsonRow } from './lib/telemetry-row-parser.mjs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { execFileSync } from 'node:child_process'
+
+const repoRoot = process.cwd()
+const tempDir = mkdtempSync(join(tmpdir(), 'idlewatch-openclaw-usage-health-'))
+const mockBinPath = join(tempDir, 'openclaw-mock.sh')
+
+function writeMockOpenClaw(pathToScript) {
+  const script = `#!/usr/bin/env bash
+set -euo pipefail
+NOW_MS="$(node -e "console.log(Date.now())")"
+
+if [[ "$1" == "usage" || "$1" == "status" || "$1" == "session" || "$1" == "session_status" ]]; then
+  cat <<JSON
+{
+  "status": {
+    "result": {
+      "stats": {
+        "current": {
+          "session": {
+            "sessionId": "health-session",
+            "agentId": "agent-health",
+            "model": "gpt-5.3-codex-health",
+            "totalTokens": 3333,
+            "tokensPerMinute": 11.11,
+            "updatedAt": ${'$'}NOW_MS
+          }
+        }
+      }
+    }
+  }
+}
+JSON
+  exit 0
+fi
+
+echo '{"error":"unsupported command"}'
+exit 2
+`
+  writeFileSync(pathToScript, script, 'utf8')
+  chmodSync(pathToScript, 0o755)
+}
+
+function readRow(output) {
+  return readTelemetryJsonRow(output)
+}
+
+function run() {
+  writeMockOpenClaw(mockBinPath)
+
+  const env = {
+    ...process.env,
+    IDLEWATCH_OPENCLAW_BIN: mockBinPath,
+    IDLEWATCH_OPENCLAW_BIN_STRICT: '1',
+    IDLEWATCH_OPENCLAW_PROBE_RETRIES: '0',
+    IDLEWATCH_USAGE_STALE_MS: '60000',
+    IDLEWATCH_USAGE_STALE_GRACE_MS: '10000',
+    IDLEWATCH_USAGE_REFRESH_REPROBES: '0',
+    IDLEWATCH_INTERVAL_MS: '1000',
+    IDLEWATCH_OPENCLAW_USAGE: 'auto'
+  }
+
+  const out = execFileSync('node', ['bin/idlewatch-agent.js', '--dry-run'], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    env,
+    stdio: ['ignore', 'pipe', 'pipe']
+  })
+
+  const row = readRow(out)
+
+  assert.equal(row?.source?.usage, 'openclaw', 'usage should be sourced from openclaw')
+  assert.equal(row?.source?.usageIngestionStatus, 'ok', 'usage ingestion should be healthy')
+  assert.equal(row?.source?.usageProbeResult, 'ok', 'usage probe should succeed')
+  assert.ok(row?.source?.usageIntegrationStatus === 'ok' || row?.source?.usageIntegrationStatus === 'aging', 'usage integration should be ok/aging')
+  assert.equal(row?.openclawSessionId, 'health-session')
+  assert.equal(row?.openclawModel, 'gpt-5.3-codex-health')
+  assert.equal(row?.openclawAgentId, 'agent-health')
+  assert.equal(row?.openclawTotalTokens, 3333)
+  assert.equal(row?.tokensPerMin, 11.11)
+  assert.ok(Number(row?.openclawUsageTs) > Date.now() - 120000, 'usage timestamp should be recent')
+
+  console.log('validate-openclaw-usage-health: ok (openclaw usage source required and healthy)')
+}
+
+try {
+  run()
+} finally {
+  rmSync(tempDir, { recursive: true, force: true })
+}

package/scripts/validate-packaged-artifact.mjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+import { accessSync, constants, readFileSync, existsSync } from 'node:fs'
+import { execSync } from 'node:child_process'
+import { join } from 'node:path'
+
+const rootDir = process.cwd()
+const artifactDir = process.env.IDLEWATCH_ARTIFACT_DIR?.trim()
+  ? process.env.IDLEWATCH_ARTIFACT_DIR.trim()
+  : join(rootDir, 'dist', 'IdleWatch.app')
+const artifactPath = join(artifactDir, 'Contents', 'MacOS', 'IdleWatch')
+const metadataPath = join(artifactDir, 'Contents', 'Resources', 'packaging-metadata.json')
+
+function fail(message) {
+  console.error(message)
+  process.exit(1)
+}
+
+function shouldRequireGitMatch(value) {
+  const normalized = String(value ?? '1').trim().toLowerCase()
+  if (['0', 'false', 'off', 'no'].includes(normalized)) return false
+  return true
+}
+
+function shouldRequireBundledRuntime(value) {
+  const normalized = String(value ?? '').trim().toLowerCase()
+  return ['1', 'true', 'on', 'yes'].includes(normalized)
+}
+
+function parseBoolean(value) {
+  const normalized = String(value ?? '').trim().toLowerCase()
+  if (['1', 'true', 'on', 'yes'].includes(normalized)) return true
+  if (['0', 'false', 'off', 'no'].includes(normalized)) return false
+  return null
+}
+
+function readCurrentCommit() {
+  try {
+    const value = execSync('git rev-parse HEAD', {
+      cwd: rootDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    }).trim()
+
+    return value
+  } catch {
+    return ''
+  }
+}
+
+function readCurrentWorkingTreeClean() {
+  try {
+    const porcelain = execSync('git status --porcelain', {
+      cwd: rootDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    }).trim()
+
+    return porcelain.length === 0
+  } catch {
+    return null
+  }
+}
+
+function resolveSourceCommit(metadata) {
+  const value = metadata?.sourceGitCommit
+  if (typeof value !== 'string') return ''
+  return value.trim()
+}
+
+function shouldAllowLegacyCommitMetadata(value) {
+  const normalized = String(value ?? '').trim().toLowerCase()
+  return ['1', 'true', 'on', 'yes', 'allow'].includes(normalized)
+}
+
+function validateMetadataConsistency(metadata) {
+  if (!metadata || typeof metadata !== 'object') {
+    fail(`Malformed packaging metadata at ${metadataPath}`)
+  }
+
+  if (typeof metadata.version !== 'string' || !metadata.version.trim()) {
+    fail(`Packaging metadata is missing a valid version: ${metadataPath}`)
+  }
+
+  const requireNodeRuntime = shouldRequireBundledRuntime(process.env.IDLEWATCH_REQUIRE_NODE_RUNTIME_BUNDLED)
+  if (requireNodeRuntime && !parseBoolean(metadata.nodeRuntimeBundled)) {
+    console.error('Packaged artifact is not marked as bundled-runtime aware. Rebuild before reuse-mode validation:')
+    console.error('  npm run package:macos')
+    fail('Rebuild artifact first (bundled-runtime metadata check failed).')
+  }
+}
+
+function validateSourceCommit(metadata, currentCommit) {
+  const requireSourceMatch = shouldRequireGitMatch(process.env.IDLEWATCH_REQUIRE_SOURCE_COMMIT_MATCH)
+  if (!requireSourceMatch) return
+
+  const sourceCommit = resolveSourceCommit(metadata)
+  if (!currentCommit) {
+    return
+  }
+
+  if (!sourceCommit) {
+    console.error('Reusable packaged artifact is missing sourceGitCommit provenance.')
+    console.error('Rebuild artifact before strict commit-matching reuse checks:')
+    console.error('  npm run package:macos')
+
+    if (shouldAllowLegacyCommitMetadata(process.env.IDLEWATCH_ALLOW_LEGACY_SOURCE_GIT_COMMIT)) {
+      console.error('Continuing with legacy compatibility mode (non-strict).')
+      console.error('Disable this path in strict runs via setting: IDLEWATCH_ALLOW_LEGACY_SOURCE_GIT_COMMIT=0 (or unset).')
+      return
+    }
+
+    fail('Rebuilt artifact is required for strict source-commit validation: sourceGitCommit is missing.')
+  }
+
+  if (sourceCommit !== currentCommit) {
+    console.error('Reused packaged artifact is stale for this workspace revision.')
+    console.error(`Current commit : ${currentCommit}`)
+    console.error(`Packaged commit: ${sourceCommit}`)
+    console.error('Rebuild artifact first:')
+    console.error('  npm run package:macos')
+    fail('Packaged artifact is stale and does not match current git revision.')
+  }
+}
+
+function shouldAllowLegacyDirtyMetadata(value) {
+  const normalized = String(value ?? '').trim().toLowerCase()
+  return ['1', 'true', 'on', 'yes', 'allow'].includes(normalized)
+}
+
+function validateSourceDirty(metadata, currentIsClean) {
+  if (!metadata || typeof metadata !== 'object' || currentIsClean === null) return
+
+  const requireDirtyMatch = shouldRequireGitMatch(process.env.IDLEWATCH_REQUIRE_SOURCE_DIRTY_MATCH)
+  if (!requireDirtyMatch) return
+
+  const dirtyKnown = metadata?.sourceGitDirtyKnown === true
+  const dirtyValue = metadata.sourceGitDirty
+
+  if (!dirtyKnown) {
+    if (typeof dirtyValue === 'boolean') {
+      console.error('Reusable packaged artifact did not reliably record dirty-state confidence at build time.')
+      console.error('Build metadata reported sourceGitDirty=' + dirtyValue + ' but sourceGitDirtyKnown is not true.')
+    } else {
+      console.error('Reusable packaged artifact did not record sourceGitDirty provenance.')
+    }
+
+    if (shouldAllowLegacyDirtyMetadata(process.env.IDLEWATCH_ALLOW_LEGACY_SOURCE_GIT_DIRTY)) {
+      console.error('Continuing with legacy compatibility mode (non-strict).')
+      console.error('Disable this path in strict runs via setting: IDLEWATCH_ALLOW_LEGACY_SOURCE_GIT_DIRTY=0 (or unset).')
+      console.error('Rebuild artifact for strict dirty-state reuse validation:')
+      console.error('  npm run package:macos')
+      return
+    }
+
+    console.error('Rebuilt artifact is required for strict dirty-state reuse validation.')
+    console.error('  npm run package:macos')
+    fail('Rebuilt artifact is required for dirty-state validation; sourceGitDirtyKnown is missing.')
+  }
+
+  const metadataWasClean = parseBoolean(dirtyValue)
+  if (metadataWasClean === null) {
+    console.error('Reusable packaged artifact has non-boolean sourceGitDirty metadata; rebuild with latest packaging script for strict dirty-state checks.')
+    if (shouldAllowLegacyDirtyMetadata(process.env.IDLEWATCH_ALLOW_LEGACY_SOURCE_GIT_DIRTY)) {
+      console.error('Continuing with legacy compatibility mode (non-strict).')
+      console.error('Disable this path in strict runs via setting: IDLEWATCH_ALLOW_LEGACY_SOURCE_GIT_DIRTY=0 (or unset).')
+      return
+    }
+
+    fail('Rebuild artifact first: sourceGitDirty must be boolean for strict dirty-state checks.')
+  }
+
+  if (currentIsClean !== metadataWasClean) {
+    console.error('Reusable packaged artifact dirty-state does not match current workspace clean-state.')
+    console.error(`Current working tree clean: ${currentIsClean}`)
+    console.error(`Packaged artifact built with clean workspace: ${metadataWasClean}`)
+    fail('Rebuild artifact first: dirty-state mismatch for reusable artifact.')
+  }
+}
+
+
+function validateFreshness(metadata) {
+  const maxAgeMs = Number(process.env.IDLEWATCH_PACKAGED_ARTIFACT_MAX_AGE_MS || '')
+  if (!Number.isFinite(maxAgeMs) || maxAgeMs <= 0) return
+
+  const parsedBuiltAt = Date.parse(metadata?.builtAt)
+  if (Number.isNaN(parsedBuiltAt)) {
+    console.error('packaging metadata is missing a parseable builtAt field; skipping age validation.')
+    return
+  }
+
+  const ageMs = Date.now() - parsedBuiltAt
+  if (ageMs > maxAgeMs) {
+    console.error(`Packaged artifact age ${ageMs}ms exceeds max ${maxAgeMs}ms.`)
+    console.error(`Artifact builtAt : ${metadata?.builtAt}`)
+    fail('Rebuild artifact first: age policy exceeded for reusable packaged artifact.')
+  }
+}
+
+function main() {
+  if (!existsSync(metadataPath)) {
+    fail(`Missing packaged metadata file: ${metadataPath}`)
+  }
+
+  let metadata
+  try {
+    metadata = JSON.parse(readFileSync(metadataPath, 'utf8'))
+  } catch (error) {
+    fail(`Failed to parse packaging metadata at ${metadataPath}: ${error?.message || error}`)
+  }
+
+  if (!existsSync(artifactPath)) {
+    fail(`Packaged launcher missing: ${artifactPath}`)
+  }
+
+  try {
+    accessSync(artifactPath, constants.X_OK)
+  } catch {
+    fail(`Packaged launcher is not executable: ${artifactPath}`)
+  }
+
+  validateMetadataConsistency(metadata)
+  const currentCommit = readCurrentCommit()
+  const currentIsClean = readCurrentWorkingTreeClean()
+  validateSourceCommit(metadata, currentCommit)
+  validateSourceDirty(metadata, currentIsClean)
+  validateFreshness(metadata)
+
+  console.log('packaged artifact reusable validation ok')
+  console.log(`artifact: ${artifactPath}`)
+  if (metadata.version) console.log(`artifact version: ${metadata.version}`)
+}
+
+main()