0.5.1

What's Changed

• fix: stabilize Native and Classic workflow recovery by @benym in #510

Changed

• Workflow recovery after manual changes: Revise requirements and plans from later phases without recreating the change, retain completed work and configuration, resume interrupted Classic Skills from their original failure records, and give Native branch takeover and pre-Archive implementation repair an executable continuation. Classic can recheck newly declared generated outputs after Archive and finish delivery without committing disposable files, recommitting Runtime-only approval updates, or repeating Archive. Recovery output presents the current command and request before accumulated approval context. Changes beyond existing authorization still need approval, and unresolved executions remain protected.
• Native incremental verification: Keep approved requirements and focused repair context when producing successor candidates, and reuse passing checks only when the Runtime can prove their complete inputs and execution conditions are unchanged. Reused results retain their original evidence; commands without complete dependency evidence run again. Reject a Verifier claim that uses the Builder's execution reference before it occupies the task, so an independent Verifier can continue immediately.
• Workflow continuation after edits: Preserve user changes when recovering Native and Classic work, let the Agent inspect applied edits and resume within existing authorization, and refresh affected or unverified evidence before proceeding. Native can restore missing approved originals from matching Git content while keeping the user's current edits.
• Native artifact requirements: Carry user-requested file locations, required sections, and formats through Shape, Build, and independent verification, so equivalent content in a different file does not satisfy the requested deliverable.
• Classic authorization reuse: Honor existing approvals and explicit delegated authority across phases. Ask about decisions beyond that authority or confirmations the user expressly requested, and record the basis without misrepresenting Agent choices as user confirmation.
• Native recovery: Report concrete blockers, lock owners, and executable recovery steps across Native and SDK commands. Inspect Run-store and application locks alongside projection locks, require an exact stopped-owner decision for unknown project locks, reconcile rejected Builder outcomes through their original claims before reconfirming changed requirements on the same change, and resume interrupted Archive transactions without repeating completed checks or specification updates. Explain how to repair malformed outcome requests using the original claim and result template.
• Personal Memory demo: Show three pages of representative memories and let reviewers use previous, next, filters, and search in the read-only preview. Let regular pages fill the available list height and align page controls with the Dashboard's text navigation style, including steady hover and press feedback.
• Badcase regression maintenance: Require traceable user-fix declarations and executable regression mappings in pull requests, preserve existing case coverage, and keep pending browser, platform, or model acceptance from being reported as a completed fix or release approval. Collect all selected groups in one run, retain their reports and a failure summary, and fail the overall run when any group fails.
• Current SDK evaluation: Add Native blocked-session recovery and Classic full/tweak/hotfix delivery tasks to the current-candidate matrix, bind recovery boundaries to actual Runtime evidence, and keep legacy portable scenarios explicitly separate from current SDK coverage. Offer focused recovery checks with one or three independent samples per hardest task and require every requested sample to pass, and bind release evidence to complete core regressions across the required platforms.
• Classic check configuration: Support a bounded project-level check timeout with explicit CLI overrides, plus opt-in output presets for Vite, .NET, and coverage artifacts. Explicitly declared ignored inputs remain part of the evidence (#502).
• Native brief structure: List only the directory categories relevant to a change, instead of filling unused categories with "None". The Directory structure section and meaningful content in each retained category remain required. Existing complete briefs remain valid.
• Classic configuration guidance: Show each execution, TDD, and review setting with its meaning and confirmation status. Ask only for missing, invalid, or explicitly changed choices, while retaining valid choices within the same change. Each new full change still requires its own configuration approval; hotfix and tweak retain their existing confirmation steps.
• Requirement reconfirmation: Before presenting the complete revised Native or Classic proposal, explain behavior changes, affected acceptance criteria, retained work, and steps that must be repeated. State when the previous approved proposal is unavailable. Approval remains bound to the complete current proposal, and old verification results do not approve new requirements.

Fixed

• Native environment-file verification: Include environment and key-named files within the existing input scope in content fingerprints, so independent repositories under a non-Git workspace can complete verification and Archive. Continue rejecting unreadable or unstable inputs and stale evidence, and report failed candidate capture without mislabeling it as legacy checks (#509).
• Eval scoring reliability: Keep recovery hashes containing 429 from being mislabeled as API rate limits, and allow reasoning-based judges enough output space to return their scores.
• Evaluation on macOS: Preserve simulator prompts and optional arguments when running interactive evaluations with the system Bash 3.2, so approval replies and completion checks can run without replacing the shell.
• Classic Archive input repair: Reopen a stopped, failed archive on the same Run only after confirming that its original inputs and specifications are unchanged and no archive directory was created. Preserve the original failure, show OpenSpec diagnostics, and require fresh approval and verification before delivery (#507).
• Classic SDK branch rebinding: Let state rebind update the original Run after switching or deleting its former branch, including recovery from a portable checkpoint. Preserve execution history, reject unresolved work, and require new verification and Archive approval for the new branch (#508).
• Native command performance: Avoid scanning unrelated ignored dependencies, temporary directories, and local worktrees when validating generated inputs, preventing repeated Git timeouts during Next and Archive. Reduce redundant Git queries while retaining fresh candidate, submodule, and generated-input checks.
• Evaluation treatment loading: Restore the public Python treatment loader with the current scaffold model while preserving configured Skills and workflow guidance.
• Native Verifier startup recovery: Let the original claimant report a failed Verifier execution even when it was claimed with the Builder identity or the approved documents have changed. Preserve the candidate and checks for recovery while still rejecting non-independent verification results.
• Evaluation provider configuration: Accept either dedicated API-key or auth-token credentials for built-in Judges and translate Claude Code's context suffix before HTTP scoring requests, so valid provider configurations can run and receive scores. Custom agents retain their declared credential requirements.
• Dashboard loading and refresh states: Align Personal Memory and Custom Workflow loading with their lists, use compact theme-colored sync indicators in workflow sidebars, and keep previously loaded Observability views visible during automatic sync, manual refresh, and tab switches so routine updates do not interrupt reading.
• Native incremental Shape and Hook ownership: Preserve approved auxiliary test-plan updates, review formal comment changes within the existing workflow, and prevent compatibility Hook mutations from splitting SDK state.
• Workflow resume intent: Honor explicit refusal and commit-only scope before resuming an active change, including Chinese and English requests.
• Classic archive evidence: Bind delivered archive and specification outputs to their recorded execution evidence, persist approved inputs before external archive effects so interrupted directory moves can resume on the original Run without replay, preserve committed archive checkpoints after delivery, and keep declared-directory deletions in the approved delivery scope. Interrupted specification synchronization without an original result receipt requires explicit user approval of the exact recovered outputs.
• Native worktree and retry boundaries: Exclude other linked worktrees from project-generated input snapshots and show verification retry choices only when supported by the current checks.
• Hook path ownership: Keep configured allow paths from bypassing workflow, Runtime, or Git ownership through ordinary or dangling symbolic links and ambiguous parent traversal. Resolve Windows short directory names before checking project scope, so writes inside the project remain guarded.
• Release evaluation integrity: Require current-candidate, complete-sample Eval evidence and mandatory historical regressions before publication; reject stale reports, failed task checks, and incomplete baselines instead of treating them as a passing release.
• Native blocked verification recovery: Make advertised retry and implementation-repair commands executable for ordinary changes, retain valid candidate/check evidence, and carry the blocker resolution into the new independent verification attempt (#505).
• Native acceptance boundaries: Respect Markdown section and list-item boundaries instead of attaching later sections to the final criterion. Preserve legacy confirmed criteria only when their original full approval evidence still matches; confirmed Shape content remains protected (#504).
• Classic delivery scope: Keep unrelated change drafts and unchanged files that predate a change out of delivery requirements, while still requiring delivery of files modified during that change. Validate approved linear commit ranges and route the compatible delivery verification entry to the owning SDK workflow without discarding its approval. Recognize Windows short-name paths when checking verified implementation files and report the actual input change instead of an outside-repository Git error (#503).
• Native verification across sessions: Validate submitted check evidence against the candidate's content rather than the submitting shell's environment, while retaining execution-environment checks when deciding whether to reuse results (#500).
• Native generated check inputs: Keep dependency trees and volatile development caches out of generated-input snapshots while binding project outputs in nested directories and Git submodules, even without a project manifest. Generated inputs are streamed into the check fingerprint without fixed file-count or byte caps, and unreadable snapshots cannot reuse old checks (#501).
• Classic check executable changes: Resolve the current executable before reusing check evidence, including PATH changes and newly installed higher-priority commands in long-lived sessions.
• Classic delivery after re-verification: Retain validated Design and Plan document references when reopening a full workflow's verification, so a newly approved archive can complete delivery without losing its document evidence. Changed documents still require renewed validation.
• Personal Memory reading: Keep desktop lists within the available height so long lists retain accessible pagination and details. Preserve list boundaries when selecting records with different detail lengths to avoid page jitter (#499).
• Native SDK Shape validation: Enforce directory structure checks for new and re-prepared SDK Shape proposals. Previously pending approvals and confirmed Build, Verify, and Archive changes retain their original document constraints and progress.
• Native archive with submodules: Bind actual submodule commits and recursively verified uncommitted content, including embedded Git repositories without a .gitmodules mapping. Preserve content-drift checks and import missing child commit objects from the change checkout before an authorized worktree merge (#506).
• Native SDK request inputs and diagnostics: Exclude validated untracked request transports from candidate inputs, including when the workspace uses a directory alias, retain tracked and ordinary files in verification, and report the invalid Builder field, acceptance ID, timestamp format, or current Verifier iteration and attempt when rejecting a result (#506).
• Native archive coordination and recovery: Finish an accepted result's pending revalidation before archiving, diagnose unavailable candidates in read-only previews and Doctor, retain business state in rejected Archive responses, and retry temporary directory sharing violations while preserving the original transaction for recovery after persistent file watchers release their handles (#506).
• Direct context access: Report unavailable task-context expansions without a Node stack trace and read existing knowledge records without an unrelated index refresh or its budget diagnostics (#506).

Security

• Dependency security updates: Upgrade CLI, Dashboard, test tooling, and Eval dependencies to patched releases, covering DOMPurify, undici, fast-uri, Vitest, Pillow, virtualenv, filelock, OpenTelemetry, and certificate trust updates. Keep both JavaScript lockfiles aligned and require patched Python dependencies when resolving the Eval environment.

Full Changelog: 0.5.0...0.5.1