fpf:actualize

Reconcile the project's FPF state with recent repository changes

771 stars

Best use case

fpf:actualize is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Reconcile the project's FPF state with recent repository changes

Teams using fpf:actualize should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/actualize/SKILL.md --create-dirs "https://raw.githubusercontent.com/NeoLabHQ/context-engineering-kit/main/plugins/fpf/skills/actualize/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/actualize/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How fpf:actualize Compares

Feature / Agentfpf:actualizeStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Reconcile the project's FPF state with recent repository changes

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Actualize Knowledge Base

This command is a core part of maintaining a living assurance case. It keeps your FPF knowledge base (`.fpf/`) in sync with the evolving reality of your project's codebase.

The command performs a three-part audit against recent git changes to surface potential context drift, stale evidence, and outdated decisions. This aligns with the **Observe** phase of the FPF Canonical Evolution Loop (B.4) and helps manage **Epistemic Debt** (B.3.4).

## Action (Run-Time)

### Step 1: Check Git Changes

Run git commands to identify changes since last actualization:

```bash
# Get current commit hash
git rev-parse HEAD

# Check for changes since last known baseline
# (Read .fpf/.baseline file if it exists, otherwise use initial commit)
git diff --name-only <baseline_commit> HEAD

# List all changed files
git diff --stat <baseline_commit> HEAD
```

### Step 2: Analyze Report for Context Drift

1. Review changed files for core project configuration:
   - `package.json`, `go.mod`, `Cargo.toml`, `requirements.txt`
   - `Dockerfile`, `docker-compose.yml`
   - `.env.example`, config files

2. If configuration files changed:
   - Re-read project structure (README, config files)
   - Compare detected context with `.fpf/context.md`
   - Present diff to user

3. Ask user if they want to update `context.md`

### Step 3: Analyze Report for Evidence Staleness (Epistemic Debt)

1. Read all evidence files in `.fpf/evidence/`
2. Check `carrier_ref` field in each evidence file
3. Cross-reference with changed files from git diff
4. If a referenced file changed:
   - Flag the evidence as **STALE**
   - Note which hypothesis is affected

### Step 4: Analyze Report for Decision Relevance

1. Read all DRR files in `.fpf/decisions/`
2. Trace back to source evidence and hypothesis files
3. If foundational files changed:
   - Flag the DRR as **POTENTIALLY OUTDATED**

### Step 5: Update Baseline

Create/update `.fpf/.baseline` file:

```
# FPF Actualization Baseline
# Last actualized: 2025-01-15T16:00:00Z
commit: abc123def456
```

### Step 6: Present Findings

Output a structured report:

```markdown
## Actualization Report

**Baseline**: abc123 (2025-01-10)
**Current**: def456 (2025-01-15)
**Files Changed**: 42

### Context Drift

The following configuration files have changed:
- package.json (+5 dependencies)
- Dockerfile (base image updated)

**Action Required**: Review and update `.fpf/context.md` if constraints have changed.

### Stale Evidence (3 items)

| Evidence | Hypothesis | Changed File |
|----------|------------|--------------|
| ev-benchmark-api | api-optimization | src/api/handler.ts |
| ev-test-auth | auth-module | src/auth/login.ts |
| ev-perf-db | db-indexing | migrations/002.sql |

**Action Required**: Re-validate to refresh evidence for affected hypotheses.

### Decisions to Review (1 item)

| DRR | Affected By |
|-----|-------------|
| DRR-2025-01-10-api-design | src/api/handler.ts changed |

**Action Required**: Consider re-evaluating decision via `/fpf:propose-hypotheses`.

### Summary

- Context drift detected: YES
- Stale evidence: 3 items
- Decisions to review: 1 item

Run `/fpf:decay` for detailed freshness management.
```

## File: .fpf/.baseline

Track the last actualization point:

```yaml
# FPF Actualization Baseline
last_actualized: 2025-01-15T16:00:00Z
commit: abc123def456789
branch: main
```

## When to Run

- **Before starting new work**: Ensure knowledge base is current
- **After major changes**: Sync evidence with code changes
- **Weekly maintenance**: Part of regular hygiene
- **Before decisions**: Ensure evidence is still valid

Related Skills

tech-stack:add-typescript-best-practices

771
from NeoLabHQ/context-engineering-kit

Setup TypeScript best practices and code style rules in CLAUDE.md

tdd:write-tests

771
from NeoLabHQ/context-engineering-kit

Systematically add test coverage for all local code changes using specialized review and development agents. Add tests for uncommitted changes (including untracked files), or if everything is commited, then will cover latest commit.

tdd:test-driven-development

771
from NeoLabHQ/context-engineering-kit

Use when implementing any feature or bugfix, before writing implementation code - write the test first, watch it fail, write minimal code to pass; ensures tests actually verify behavior by requiring failure first

tdd:fix-tests

771
from NeoLabHQ/context-engineering-kit

Systematically fix all failing tests after business logic changes or refactoring

sdd:plan

771
from NeoLabHQ/context-engineering-kit

Refine, parallelize, and verify a draft task specification into a fully planned implementation-ready task

sdd:implement

771
from NeoLabHQ/context-engineering-kit

Implement a task with automated LLM-as-Judge verification for critical steps

sdd:create-ideas

771
from NeoLabHQ/context-engineering-kit

Generate ideas in one shot using creative sampling

sdd:brainstorm

771
from NeoLabHQ/context-engineering-kit

Use when creating or developing, before writing code or implementation plans - refines rough ideas into fully-formed designs through collaborative questioning, alternative exploration, and incremental validation. Don't use during clear 'mechanical' processes

sdd:add-task

771
from NeoLabHQ/context-engineering-kit

creates draft task file in .specs/tasks/draft/ with original user intent

sadd:tree-of-thoughts

771
from NeoLabHQ/context-engineering-kit

Execute tasks through systematic exploration, pruning, and expansion using Tree of Thoughts methodology with meta-judge evaluation specifications and multi-agent evaluation

sadd:subagent-driven-development

771
from NeoLabHQ/context-engineering-kit

Use when executing implementation plans with independent tasks in the current session or facing 3+ independent issues that can be investigated without shared state or dependencies - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates

sadd:multi-agent-patterns

771
from NeoLabHQ/context-engineering-kit

Design multi-agent architectures for complex tasks. Use when single-agent context limits are exceeded, when tasks decompose naturally into subtasks, or when specializing agents improves quality.