Done means proven

Complete task with evidence

Turn a completion claim into an auditable receipt. Every result shows what was inspected, what passed, and what did not.

Submit completion claim

Required claim details, followed by optional proof.

Task claim

Identify exactly what is being marked complete.

Task ID (required)

Enter a task ID.

Summary (required)

Enter a completion summary.

Submitted evidence

A valid commit or passing command can verify the claim.

Commit SHA

Checks that the object exists with git cat-file -e.

The preview fixture recognizes one known repository commit.

Test command

Runs from the repository root and captures the final 20 output lines.

Try npm test or npm run test:fail in this local preview.

Media reference

Recorded in the receipt, but not independently verified.

Media does not count as verified evidence by itself.

Add at least one verifiable item to prove completion.

Verification receipt

Local fixture preview. No repository data is changed.

Awaiting evidence

Add at least one verifiable item to prove completion.

task claim evidence receipt

Required cases

Compare verification outcomes

Run any case repeatedly. The form and receipt update together.

Case 01

Valid commit

Verified

Commit SHA 7c9a4d21f6a0138b5e7d4c91ac66be108f2d7a34

The commit exists, so the completion claim receives a verified receipt.

Case 02

Fabricated commit

Claimed unverified

Commit SHA deadbeefdeadbeefdeadbeefdeadbeefdeadbeef

Commit was not found.

Case 03

No evidence

Claimed unverified

Submitted evidence None supplied

No evidence was supplied.

REPO_PATH=/path/to/streampilot-demo-app node complete-task.js --demo

#!/usr/bin/env node
const { spawnSync } = require('node:child_process');
const path = require('node:path');

const repo = path.resolve(process.env.REPO_PATH || process.cwd());
const now = () => new Date().toISOString();
const last20 = (value) =>
  String(value || '')
    .split(/\r?\n/)
    .filter(Boolean)
    .slice(-20);

function run(command, args) {
  const result = spawnSync(command, args, {
    cwd: repo,
    encoding: 'utf8',
    shell: !args
  });

return {
    outcome: result.error
      ? 'execution_error'
      : result.status === 0
        ? 'passed'
        : 'failed',
    exit_code: Number.isInteger(result.status) ? result.status : null,
    checked_at: now(),
    output_last_20_lines: last20(
      [result.stdout, result.stderr, result.error?.message]
        .filter(Boolean)
        .join('\n')
    )
  };
}

function reasonFor(evidence, checks) {
  const supplied = Boolean(
    evidence.commit_sha ||
    evidence.test_command ||
    evidence.media_ref
  );

if (!supplied) return 'No evidence was supplied.';

const commit = checks.find((check) => check.kind === 'commit_sha');
  const test = checks.find((check) => check.kind === 'test_command');

if (commit?.outcome === 'failed' && !test) {
    return 'Commit was not found.';
  }

if (test?.outcome === 'execution_error') {
    return 'The test command could not be launched.';
  }

if (checks.every((check) => check.kind === 'media_ref')) {
    return 'Media reference was recorded, but no verifiable evidence was supplied.';
  }

return 'No submitted check passed.';
}

function completeTask(input) {
  const startedAt = now();
  const evidence = input.evidence || {};
  const checks = [];

if (evidence.commit_sha) {
    checks.push({
      kind: 'commit_sha',
      inspected: evidence.commit_sha,
      command: `git cat-file -e ${evidence.commit_sha}`,
      ...run('git', ['cat-file', '-e', evidence.commit_sha])
    });
  }

if (evidence.test_command) {
    checks.push({
      kind: 'test_command',
      inspected: evidence.test_command,
      command: evidence.test_command,
      ...run(evidence.test_command)
    });
  }

if (evidence.media_ref) {
    checks.push({
      kind: 'media_ref',
      inspected: evidence.media_ref,
      reference: evidence.media_ref,
      outcome: 'recorded',
      exit_code: null,
      checked_at: now(),
      output_last_20_lines: []
    });
  }

const verified = checks.some(
    (check) =>
      ['commit_sha', 'test_command'].includes(check.kind) &&
      check.outcome === 'passed'
  );

return {
    status: verified ? 'verified' : 'claimed_unverified',
    ...(verified ? {} : { reason: reasonFor(evidence, checks) }),
    receipt: {
      task: {
        task_id: input.task_id,
        summary: input.summary
      },
      submitted_evidence: evidence,
      started_at: startedAt,
      completed_at: now(),
      checks
    }
  };
}

function readStdin() {
  return new Promise((resolve, reject) => {
    let body = '';
    process.stdin.setEncoding('utf8');
    process.stdin.on('data', (chunk) => { body += chunk; });
    process.stdin.on('end', () => resolve(body));
    process.stdin.on('error', reject);
  });
}

async function main() {
  if (process.argv.includes('--demo')) {
    const head = spawnSync('git', ['rev-parse', 'HEAD'], {
      cwd: repo,
      encoding: 'utf8'
    });

if (head.status !== 0) {
      throw new Error('Demo repository is unavailable.');
    }

const validSha = head.stdout.trim();
    const demos = [
      completeTask({
        task_id: 'demo-valid-commit',
        summary: 'Valid commit evidence',
        evidence: { commit_sha: validSha }
      }),
      completeTask({
        task_id: 'demo-fabricated-commit',
        summary: 'Fabricated commit evidence',
        evidence: {
          commit_sha: 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeef'
        }
      }),
      completeTask({
        task_id: 'demo-no-evidence',
        summary: 'Completion claim without evidence',
        evidence: {}
      })
    ];

console.log(JSON.stringify({ demos }, null, 2));
    return;
  }

const raw = await readStdin();
  console.log(JSON.stringify(completeTask(JSON.parse(raw)), null, 2));
}

main().catch((error) => {
  console.error(JSON.stringify({
    status: 'error',
    reason: error.message
  }, null, 2));
  process.exitCode = 1;
});