Migrate jesslyn-photographer-workflow from Ty_Tech/research to Tony_tech/research (step 2/4)

2026-06-18 04:45:50 +00:00
parent fa6119608f
commit ca594c8ece
1 changed files with 106 additions and 0 deletions
@@ -0,0 +1,106 @@
 # Phase 1: Automated Culling Persistence Experiment
 **Focus**: Automated Culling (top recommendation from Odysseus report alongside Personal Style Learning)
 **Rationale**: User reports Jesslyn spends a significant time on culling. This is a high-pain, high-volume task where true persistence can deliver clear value (remembering style/priorities across shoots). Aligns with report's "strongest candidates" and our discovery goals. We proceed with known information since detailed workflow mapping from Jesslyn is pending.
 **Date**: 2026-06-17
 **Status**: Planning / Narrowed Scope
 **Parent**: jesslyn-photographer-workflow experiment
 **Related**: 
 - Odysseus report (research/odysseus-report-rp-222259c2ba04.md)
 - 8 Use Cases baseline (research/use-cases-qwen.md)
 - Main README (updated with 5 pillars)
 ## What We Know (Current Baseline)
 - Jesslyn spends a lot of time culling photos (primary pain point identified).
 - From research baseline:
  - Tools like Aftershoot, Photo Mechanic + AI, FilterPixel, Narrative Select, Imagen AI, Apex Culler.
  - Current "persistence": Folder monitoring, blink/soft-focus/blur detection, near-duplicate grouping, ratings/tags, up to 95% accuracy claims.
  - Limitations: Mostly technical flagging + rules; limited cross-shoot style memory or client-specific adaptation.
 - General photography context: Culling can consume 30-40% of post-production time for high-volume shoots (e.g., weddings).
 ## Hermes-Style Persistence Applied to Culling
 Using the 5 pillars from the Odysseus report as the framework:
 1. **Cross-Shoot Memory**
   - Agent remembers past culling decisions for similar shoots/clients.
   - Example: "For this client last time, you kept the slightly soft wide shots for storytelling even if technically imperfect."
   - Uses artifacts to store style bible + historic culling logs (keeps vs. discards + reasons).
 2. **State + Context Across Workflow Stages**
   - Pre-shoot notes (e.g., "focus on candid moments") directly influence culling priorities.
   - Client feedback from previous deliveries adjusts future culling (e.g., "client hated overly posed shots").
 3. **Sub-Agent Coordination**
   - Culling agent passes context to downstream agents (e.g., "these 50 images flagged as keepers — pass to retouching agent with style notes").
   - Could coordinate with metadata tagging or proof delivery later.
 4. **Self-Improvement from Corrections**
   - When Jesslyn overrides (keeps a "bad" image or deletes a "good" one), agent learns and updates its model for future similar cases.
   - Log corrections with context for continuous refinement.
 5. **Local-First + Explainable Decisions**
   - Run culling analysis locally where possible (privacy for client images).
   - Explain decisions: "Flagged for culling because: blink detected + low contrast compared to your preferred style from [past shoot]."
   - Human always has final veto.
 ## Proposed Phase 1 Scope (Narrow & Testable)
 **Goal**: Build a minimal persistent culling assistant that demonstrates the 5 pillars using Hermes tools (artifacts, state, sub-agents, feedback).
 **Inputs** (simulated or provided):
 - Folder of raw images (or descriptions).
 - Pre-shoot brief / client notes.
 - Historical culling data (past shoots: what was kept/discarded + why, if available).
 - Photographer's style profile (initially seeded from general knowledge + report).
 **Core Capabilities to Prototype**:
 - Technical analysis (blinks, focus, exposure — can leverage existing models or simple rules initially).
 - Style-based decisions (cross-shoot memory via artifacts).
 - Context-aware prioritization (e.g., favor candid if pre-shoot says so).
 - Output: Suggested cull list with explanations + ratings.
 - Feedback loop: Log overrides and update persistent profile.
 **Out of Scope for Phase 1**:
 - Full UI / on-set integration.
 - Advanced vision (unless local model available).
 - Integration with specific software (Lightroom, Capture One) yet.
 - Other use cases (retouching, delivery, etc.).
 **Success Metrics for This Slice** (tied to 5 pillars):
 - Cross-shoot: Agent recalls and applies at least one prior decision without re-prompting.
 - State/Context: Pre-shoot notes visibly affect culling output.
 - Self-improvement: After 2-3 correction examples, behavior changes on similar images.
 - Explainability: Every suggestion includes clear "why" tied to memory or rules.
 - Time/Quality: Simulated reduction in manual review time; human agrees with 80%+ of suggestions on test sets.
 - Persistence test: Same agent instance "remembers" across multiple simulated sessions/shoots.
 ## Hermes Implementation Ideas
 - **Artifacts**: Store "Culling Style Bible" (rules + examples from past), historical cull logs per client/shoot.
 - **State Files**: Current project state (pre-shoot notes, shoot metadata, in-progress cull decisions).
 - **Sub-Agents**: One for technical flagging, one for style/context matching, one for explanation generation.
 - **Feedback**: Explicit correction interface that updates artifacts/state.
 - **Persistence Test**: Run "Session 1" (cull new shoot), apply corrections, run "Session 2" (similar shoot) — measure recall and adaptation.
 - **Local/VPS**: Vision-heavy analysis local; memory/reasoning on VPS if needed.
 - **Logging**: Everything — decisions, corrections, memory retrievals — for discovery insights.
 ## Risks & Mitigations (from Report + General)
 - Over-culling artistic choices: Mitigate with strong explainability + easy overrides.
 - Privacy: Local-first where possible.
 - Cold start: Seed initial profile with what we know + general photography best practices; improve via feedback.
 - Evaluation: Use synthetic or anonymized test sets until real data available.
 ## Next Steps for This Focus
 1. Define detailed culling agent spec (inputs/outputs, memory schema).
 2. Create initial "Culling Style Profile" artifact (seeded with known info).
 3. Prototype minimal version (perhaps using existing Hermes skills + simple rules + artifact lookup).
 4. Design persistence test protocol (multiple sessions, correction logging).
 5. When Jesslyn responds: Incorporate real workflow details and actual sample data.
 ## Open Questions
 - Do we have (or can we simulate) example culling data from past shoots?
 - Preferred output format (e.g., ratings, tags, delete list, gallery groups)?
 - Any specific technical criteria she uses (beyond general blinks/soft focus)?
 - How to measure "time spent" currently for baseline?
 This narrows the discovery to a concrete, high-value slice while staying true to testing real persistence.