outcomeci-cli 0.1.0__tar.gz

outcomeci_cli-0.1.0/.github/workflows/dependency-scan.yml

@@ -0,0 +1,23 @@
+name: Dependency scan
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+  schedule:
+    - cron: "0 7 * * 1"
+  workflow_dispatch:
+
+jobs:
+  audit:
+    name: pip-audit
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: pip install -e '.[test]' pip-audit
+      - run: pip-audit --skip-editable

outcomeci_cli-0.1.0/.github/workflows/homebrew.yml

@@ -0,0 +1,62 @@
+name: Update Homebrew tap
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Released tag to point the formula at, e.g. v0.1.0"
+        required: true
+        type: string
+
+jobs:
+  bump:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Resolve version
+        id: version
+        env:
+          TAG: ${{ inputs.tag || github.ref_name }}
+        run: echo "version=${TAG#v}" >> "$GITHUB_OUTPUT"
+      - name: Wait for PyPI sdist
+        id: pypi
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          for i in $(seq 1 30); do
+            JSON=$(curl -fsSL "https://pypi.org/pypi/outcomeci-cli/${VERSION}/json" || true)
+            URL=$(printf '%s' "$JSON" | jq -r '.urls[]? | select(.packagetype=="sdist") | .url')
+            SHA=$(printf '%s' "$JSON" | jq -r '.urls[]? | select(.packagetype=="sdist") | .digests.sha256')
+            if [ -n "$URL" ] && [ "$URL" != "null" ]; then break; fi
+            sleep 10
+          done
+          if [ -z "$URL" ] || [ "$URL" = "null" ]; then exit 1; fi
+          echo "url=$URL" >> "$GITHUB_OUTPUT"
+          echo "sha=$SHA" >> "$GITHUB_OUTPUT"
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ inputs.tag || github.ref_name }}
+          path: source
+      - uses: actions/checkout@v7
+        with:
+          repository: outcomeci/homebrew-tap
+          token: ${{ secrets.HOMEBREW_TAP_TOKEN }}
+          path: tap
+      - name: Update formula and resources
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+          URL: ${{ steps.pypi.outputs.url }}
+          SHA: ${{ steps.pypi.outputs.sha }}
+        run: |
+          F=tap/Formula/outcomeci-cli.rb
+          mkdir -p tap/Formula
+          if [ ! -f "$F" ]; then cp source/packaging/outcomeci-cli.rb "$F"; fi
+          sed -i -E "s#^  url \".*\"#  url \"${URL}\"#" "$F"
+          sed -i -E "s#^  sha256 \".*\"#  sha256 \"${SHA}\"#" "$F"
+          python3 source/scripts/refresh-homebrew-resources.py "$F" "$VERSION"
+          git -C tap config user.name "github-actions[bot]"
+          git -C tap config user.email "github-actions[bot]@users.noreply.github.com"
+          if git -C tap diff --quiet; then exit 0; fi
+          git -C tap add Formula/outcomeci-cli.rb
+          git -C tap commit -m "outcomeci-cli ${VERSION}"
+          git -C tap push

outcomeci_cli-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,95 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Tag to release, e.g. v0.1.0"
+        required: true
+        type: string
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ inputs.tag || github.ref_name }}
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - name: Verify tag matches package
+        env:
+          TAG: ${{ inputs.tag || github.ref_name }}
+        run: |
+          python - <<'PY'
+          import email, os, pathlib, sys, zipfile
+          expected = os.environ["TAG"].removeprefix("v")
+          wheel = next(pathlib.Path("dist").glob("*.whl"))
+          with zipfile.ZipFile(wheel) as archive:
+              path = next(name for name in archive.namelist() if name.endswith(".dist-info/METADATA"))
+              actual = email.message_from_bytes(archive.read(path))["Version"]
+          if expected != actual:
+              sys.exit(f"tag {expected} does not match built package version {actual}")
+          PY
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  release:
+    needs: publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ inputs.tag || github.ref_name }}
+          fetch-depth: 0
+      - name: Resolve release range
+        id: release-range
+        env:
+          TAG: ${{ inputs.tag || github.ref_name }}
+        run: scripts/release-range.sh "$TAG" "$GITHUB_OUTPUT"
+      - name: Resolve version
+        id: version
+        env:
+          TAG: ${{ inputs.tag || github.ref_name }}
+        run: echo "version=${TAG#v}" >> "$GITHUB_OUTPUT"
+      - uses: aws-actions/configure-aws-credentials@v6
+        with:
+          role-to-assume: ${{ vars.CHANGELOG_AWS_ROLE_ARN }}
+          aws-region: ${{ vars.AWS_REGION || 'us-east-1' }}
+      - name: Render release notes
+        id: changelog
+        uses: outcomeci/spareparts-changelog@v0
+        with:
+          provider: anthropic
+          instructions: ${{ vars.CHANGELOG_INSTRUCTIONS }}
+          anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }}
+          from: ${{ steps.release-range.outputs.from }}
+          to: ${{ steps.release-range.outputs.to }}
+          title: ${{ inputs.tag || github.ref_name }}
+          write-repository: "false"
+          publish-s3: "true"
+          s3-bucket: ${{ vars.CHANGELOG_S3_BUCKET }}
+          s3-key: releases/outcomeci-cli/${{ steps.version.outputs.version }}.md
+          s3-region: ${{ vars.AWS_REGION || 'us-east-1' }}
+          publish-linkedin: "false"
+      - name: Create GitHub release
+        env:
+          RELEASE_NOTES: ${{ steps.changelog.outputs.markdown }}
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ inputs.tag || github.ref_name }}
+        run: |
+          test -n "$RELEASE_NOTES"
+          printf '%s\n' "$RELEASE_NOTES" > release-notes.md
+          gh release create "$TAG" --notes-file release-notes.md --verify-tag

outcomeci_cli-0.1.0/.github/workflows/secret-scan.yml

@@ -0,0 +1,44 @@
+name: Secret scan
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  secrets:
+    name: trufflehog
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    env:
+      TRUFFLEHOG_VERSION: "3.95.9"
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - name: Resolve scan base
+        id: base
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          PR_BASE: ${{ github.event.pull_request.base.sha }}
+          PUSH_BEFORE: ${{ github.event.before }}
+        run: |
+          if [ "$EVENT_NAME" = "pull_request" ]; then
+            echo "since=$PR_BASE" >> "$GITHUB_OUTPUT"
+          elif [ "$PUSH_BEFORE" = "0000000000000000000000000000000000000000" ] || [ -z "$PUSH_BEFORE" ]; then
+            echo "since=" >> "$GITHUB_OUTPUT"
+          else
+            echo "since=$PUSH_BEFORE" >> "$GITHUB_OUTPUT"
+          fi
+      - name: Install TruffleHog
+        run: |
+          curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh \
+            | sh -s -- -b /usr/local/bin "v${TRUFFLEHOG_VERSION}"
+      - name: Scan for secrets
+        env:
+          SINCE: ${{ steps.base.outputs.since }}
+        run: |
+          set -- git "file://." --results=verified,unknown --fail --no-update --exclude-detectors=Lob
+          if [ -n "$SINCE" ]; then set -- "$@" --since-commit "$SINCE"; fi
+          trufflehog "$@"

outcomeci_cli-0.1.0/.github/workflows/semantic-release.yml

@@ -0,0 +1,56 @@
+name: Semantic release
+
+on:
+  push:
+    branches: [main]
+
+concurrency:
+  group: semantic-release
+  cancel-in-progress: false
+
+permissions:
+  contents: write
+  actions: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: pip install "commitizen>=4,<5"
+      - name: Create next semantic version tag
+        id: version
+        shell: bash
+        run: |
+          set +e
+          OUTPUT=$(cz bump --get-next 2>&1)
+          STATUS=$?
+          set -e
+          if [ "$STATUS" -eq 3 ] || [ "$STATUS" -eq 21 ]; then
+            echo "released=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          if [ "$STATUS" -ne 0 ]; then printf '%s\n' "$OUTPUT"; exit "$STATUS"; fi
+          NEXT_VERSION=$(printf '%s\n' "$OUTPUT" | tail -n 1)
+          if ! [[ "$NEXT_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+([+-][0-9A-Za-z.-]+)?$ ]]; then
+            echo "::error::Commitizen returned an invalid version: $NEXT_VERSION"
+            exit 1
+          fi
+          TAG="v${NEXT_VERSION}"
+          git tag "$TAG"
+          git push origin "$TAG"
+          echo "released=true" >> "$GITHUB_OUTPUT"
+          echo "tag=$TAG" >> "$GITHUB_OUTPUT"
+      - name: Publish package and update Homebrew
+        if: steps.version.outputs.released == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ steps.version.outputs.tag }}
+        run: |
+          gh workflow run publish.yml --ref main -f tag="$TAG"
+          gh workflow run homebrew.yml --ref main -f tag="$TAG"

outcomeci_cli-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,43 @@
+name: Tests
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  pytest:
+    name: pytest on Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e '.[test]'
+      - run: pytest -q
+
+  build:
+    name: build and inspect distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: pip install build twine
+      - run: python -m build
+      - run: twine check dist/*
+      - name: Verify installed command
+        run: |
+          pip install --force-reinstall dist/*.whl
+          oci --version
+          oci outcome --help

outcomeci_cli-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+dist/
+build/
+*.egg-info/
+__pycache__/
+.pytest_cache/
+

outcomeci_cli-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.5
+Name: outcomeci-cli
+Version: 0.1.0
+Summary: Portable Standup and outcome workflow runtime for OutcomeCI
+License: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: test
+Requires-Dist: build>=1.2; extra == 'test'
+Requires-Dist: pytest>=8.3; extra == 'test'
+Description-Content-Type: text/markdown
+
+# OutcomeCI CLI
+
+`oci` installs and executes the open-source Standup framework used by OutcomeCI.
+
+```console
+pip install outcomeci-cli
+oci init
+oci validate
+oci outcome run --claim /workspace/outcome-claim.json --workspace /workspace
+```
+
+Repository context and workflow instructions live in `.outcomeci/`. The same
+`outcome.yml` contract can run locally or use OutcomeCI Cloud for managed state,
+Digital Twin context, expert messaging, credentials, and runners.
+
+To run the discovery phases with a locally installed Codex or Claude Code:
+
+```console
+oci init --backend filesystem
+oci outcome compile outcome.yml
+oci outcome start "Describe the outcome you want"
+oci outcome status
+oci outcome continue <run-id> --approve
+```
+
+`start` performs intake. Each approved `continue` advances to plan and then
+tasks. Local state, artifacts, manifests, transcripts, and usage records are
+written beneath `.outcomeci/outcomes/<run-id>/`. Runner and model defaults come
+from `outcome.yml`; `--agent` and `--model` provide per-invocation overrides.
+
+`oci init` also installs repository-local Outcome skills for Codex and Claude
+Code. They use the current interactive session rather than launching a child
+process:
+
+```text
+Codex:       $outcome Describe the outcome you want
+Claude Code: /outcome Describe the outcome you want
+```
+
+The skill coordinates `outcome begin`, `compile`, `validate-artifacts`,
+`advance`, and `status`. Managed OutcomeCI runners continue to use `outcome
+run --claim ...`; both modes share workflow compilation and artifact schemas.
+
+Filesystem workflows can pin repository evidence explicitly:
+
+```yaml
+spec:
+  context:
+    provider: filesystem
+    include:
+      - .outcomeci/context/**
+      - docs/**
+    exclude:
+      - node_modules/**
+      - dist/**
+```
+
+Compiled context records each matched path, size, and SHA-256 hash. Context
+changes therefore produce a new workflow revision. Files remain in place and
+are read by the active local agent; they are not copied into `outcome.yml`.

outcomeci_cli-0.1.0/README.md

@@ -0,0 +1,60 @@
+# OutcomeCI CLI
+
+`oci` installs and executes the open-source Standup framework used by OutcomeCI.
+
+```console
+pip install outcomeci-cli
+oci init
+oci validate
+oci outcome run --claim /workspace/outcome-claim.json --workspace /workspace
+```
+
+Repository context and workflow instructions live in `.outcomeci/`. The same
+`outcome.yml` contract can run locally or use OutcomeCI Cloud for managed state,
+Digital Twin context, expert messaging, credentials, and runners.
+
+To run the discovery phases with a locally installed Codex or Claude Code:
+
+```console
+oci init --backend filesystem
+oci outcome compile outcome.yml
+oci outcome start "Describe the outcome you want"
+oci outcome status
+oci outcome continue <run-id> --approve
+```
+
+`start` performs intake. Each approved `continue` advances to plan and then
+tasks. Local state, artifacts, manifests, transcripts, and usage records are
+written beneath `.outcomeci/outcomes/<run-id>/`. Runner and model defaults come
+from `outcome.yml`; `--agent` and `--model` provide per-invocation overrides.
+
+`oci init` also installs repository-local Outcome skills for Codex and Claude
+Code. They use the current interactive session rather than launching a child
+process:
+
+```text
+Codex:       $outcome Describe the outcome you want
+Claude Code: /outcome Describe the outcome you want
+```
+
+The skill coordinates `outcome begin`, `compile`, `validate-artifacts`,
+`advance`, and `status`. Managed OutcomeCI runners continue to use `outcome
+run --claim ...`; both modes share workflow compilation and artifact schemas.
+
+Filesystem workflows can pin repository evidence explicitly:
+
+```yaml
+spec:
+  context:
+    provider: filesystem
+    include:
+      - .outcomeci/context/**
+      - docs/**
+    exclude:
+      - node_modules/**
+      - dist/**
+```
+
+Compiled context records each matched path, size, and SHA-256 hash. Context
+changes therefore produce a new workflow revision. Files remain in place and
+are read by the active local agent; they are not copied into `outcome.yml`.

outcomeci_cli-0.1.0/packaging/outcomeci-cli.rb

@@ -0,0 +1,19 @@
+class OutcomeciCli < Formula
+  include Language::Python::Virtualenv
+
+  desc "Portable Standup and outcome workflow runtime"
+  homepage "https://github.com/outcomeci/cli"
+  url "https://files.pythonhosted.org/packages/source/o/outcomeci-cli/outcomeci_cli-0.1.0.tar.gz"
+  sha256 "0000000000000000000000000000000000000000000000000000000000000000"
+
+  depends_on "python@3.12"
+
+  def install
+    virtualenv_install_with_resources
+  end
+
+  test do
+    assert_match "oci", shell_output("#{bin}/oci --help")
+    assert_match version.to_s, shell_output("#{bin}/oci --version")
+  end
+end

outcomeci_cli-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling>=1.27", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "outcomeci-cli"
+dynamic = ["version"]
+description = "Portable Standup and outcome workflow runtime for OutcomeCI"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Apache-2.0" }
+dependencies = ["PyYAML>=6.0"]
+
+[project.scripts]
+oci = "outcomeci.cli:main"
+
+[project.optional-dependencies]
+test = ["pytest>=8.3", "build>=1.2"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/outcomeci"]
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.version.raw-options]
+version_scheme = "no-guess-dev"
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version_provider = "scm"
+version_scheme = "semver2"
+tag_format = "v${version}"
+major_version_zero = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

outcomeci_cli-0.1.0/scripts/refresh-homebrew-resources.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""Refresh Homebrew Python resource blocks from a published OutcomeCI release."""
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import sys
+import tempfile
+import urllib.request
+import venv
+
+formula, version = sys.argv[1], sys.argv[2]
+temporary = tempfile.mkdtemp()
+venv.create(f"{temporary}/venv", with_pip=True)
+pip = f"{temporary}/venv/bin/pip"
+subprocess.check_call([pip, "install", "-q", f"outcomeci-cli=={version}"])
+freeze = subprocess.check_output([pip, "list", "--format=freeze"], text=True)
+dependencies = []
+for line in freeze.splitlines():
+    if "==" in line:
+        name, dependency_version = line.split("==", 1)
+        if name.casefold() not in {"outcomeci-cli", "pip", "setuptools", "wheel"}:
+            dependencies.append((name, dependency_version))
+blocks = []
+for name, dependency_version in sorted(dependencies, key=lambda item: item[0].casefold()):
+    with urllib.request.urlopen(f"https://pypi.org/pypi/{name}/{dependency_version}/json") as response:
+        metadata = json.load(response)
+    sdist = next(item for item in metadata["urls"] if item["packagetype"] == "sdist")
+    blocks.append(f'  resource "{metadata["info"]["name"]}" do\n    url "{sdist["url"]}"\n    sha256 "{sdist["digests"]["sha256"]}"\n  end')
+text = open(formula, encoding="utf-8").read()
+text = re.sub(r'\n  resource "[^"]+" do\n(?:.*\n)*?  end\n', '\n', text)
+text = re.sub(r'(  depends_on "python@[^"]+"\n)', r'\1\n' + "\n\n".join(blocks) + "\n", text, count=1)
+open(formula, "w", encoding="utf-8").write(re.sub(r'\n{3,}', '\n\n', text))

outcomeci_cli-0.1.0/scripts/release-range.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+current_tag=${1:-}
+output_file=${2:-}
+if [[ ! $current_tag =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]] || [[ -z $output_file ]]; then
+  echo "usage: release-range.sh vMAJOR.MINOR.PATCH OUTPUT" >&2
+  exit 1
+fi
+git rev-parse --verify "${current_tag}^{commit}" >/dev/null
+previous_tag=$(git tag --merged "$current_tag" --list 'v*' | awk '$0 ~ /^v[0-9]+\.[0-9]+\.[0-9]+$/' | awk -v current="$current_tag" '$0 != current' | sort -V -r | head -n 1)
+if [[ -n $previous_tag ]]; then
+  from_revision=$previous_tag
+else
+  from_revision=$(git rev-list --max-parents=0 "$current_tag" | tail -n 1)
+fi
+if [[ -z $from_revision ]] || [[ $(git rev-parse "${from_revision}^{commit}") == $(git rev-parse "${current_tag}^{commit}") ]]; then
+  echo "release range is empty" >&2
+  exit 1
+fi
+printf 'from=%s\nto=%s\n' "$from_revision" "$current_tag" >> "$output_file"

outcomeci_cli-0.1.0/specs/001-standup-runtime/plan.md

@@ -0,0 +1,11 @@
+# Implementation Plan: Standup Runtime
+
+1. Create a dependency-light Python package and lazy command router.
+2. Add deterministic repository initialization and update behavior.
+3. Validate and compile `outcome.yml` plus referenced instruction content.
+4. Port the bounded Outcome executor, GitHub checkout, agent adapters,
+   transcript normalization, and Digital Twin client under OutcomeCI naming.
+5. Add contract and package tests, build a wheel, and install it into the local
+   Outcome runner image.
+6. Change the API-issued command and runner environment to `oci` / `OUTCOMECI_*`.
+

outcomeci_cli-0.1.0/specs/001-standup-runtime/spec.md

@@ -0,0 +1,30 @@
+# Feature Specification: Standup Runtime
+
+## Goal
+
+Publish a clean OutcomeCI CLI that lets engineers initialize and inspect the
+Standup framework while allowing OutcomeCI Cloud to delegate bounded outcome
+phases to Codex or Claude Code through the same workflow contract.
+
+## Requirements
+
+- Expose `oci init`, `oci update`, `oci validate`, `oci status`, `oci outcome`,
+  and `oci twin` without legacy Spare Parts command aliases.
+- Store repository context under `.outcomeci/` and call the framework Standup.
+- Make `outcome.yml` the orchestration policy and Markdown the readable
+  instruction body included in its deterministic compiled revision.
+- Run intake, plan, and tasks against immutable product checkouts while writing
+  versioned artifacts and evidence only to the state repository.
+- Accept only bounded, revision-pinned tools and credentials supplied by the
+  OutcomeCI API claim.
+- Capture native agent transcripts and normalized token usage.
+
+## Acceptance Criteria
+
+- A fresh repository can be initialized and validated.
+- Editing referenced YAML or Markdown changes the compiled workflow revision.
+- A local wheel exposes the `oci` executable.
+- The Outcome runner container can install that wheel and successfully invoke
+  `oci outcome run` from an API claim.
+- No public interface writes `.sp/`, invokes `sp`, or generates Huddle naming.
+

outcomeci_cli-0.1.0/specs/001-standup-runtime/tasks.md

@@ -0,0 +1,14 @@
+# Tasks: Standup Runtime
+
+- [x] Scaffold the `outcomeci-cli` distribution and `oci` entrypoint.
+- [x] Implement `.outcomeci/` initialization, update, validation, and status.
+- [x] Add default `outcome.yml` and Standup/phase instruction templates.
+- [x] Compile referenced instructions into the workflow revision.
+- [x] Port the Digital Twin job-scoped search client.
+- [x] Port agent invocation and bounded phase execution for intake, plan, and tasks.
+- [x] Generate `standup.md`, manifests, transcripts, and usage records.
+- [x] Add tests and build the local wheel.
+- [x] Update API claim command and OutcomeCI environment names.
+- [x] Build the local agent-runner image with the wheel and run initialization/validation smoke checks.
+- [ ] Initialize the development state repository and run a live API-issued claim.
+- [ ] Fold implementation and PR phases into the OutcomeCI executor.

outcomeci_cli-0.1.0/src/outcomeci/__init__.py

@@ -0,0 +1,7 @@
+"""OutcomeCI portable workflow runtime."""
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("outcomeci-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0"