From cade276c2086afb77567dfde75a0e23bd0182864 Mon Sep 17 00:00:00 2001 From: Garry Tan Date: Sun, 29 Mar 2026 21:04:35 -0700 Subject: [PATCH] =?UTF-8?q?feat:=20operational=20self-improvement=20?= =?UTF-8?q?=E2=80=94=20every=20skill=20learns=20from=20failures?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds universal operational learning capture to the preamble completion protocol. At the end of every skill session, the agent reflects on CLI failures, wrong approaches, and project quirks, logging them as type "operational" to the learnings JSONL. Future sessions surface these automatically. - generateCompletionStatus(ctx) now includes operational capture section - Preamble bash shows top 3 learnings inline when count > 5 - New "operational" type in generateLearningsLog alongside pattern/pitfall/etc - Updated unit tests + operational seed entry in learnings E2E Co-Authored-By: Claude Opus 4.6 (1M context) --- SKILL.md | 21 +++++++++++++++++++++ autoplan/SKILL.md | 21 +++++++++++++++++++++ benchmark/SKILL.md | 21 +++++++++++++++++++++ browse/SKILL.md | 21 +++++++++++++++++++++ canary/SKILL.md | 21 +++++++++++++++++++++ codex/SKILL.md | 21 +++++++++++++++++++++ connect-chrome/SKILL.md | 21 +++++++++++++++++++++ cso/SKILL.md | 21 +++++++++++++++++++++ design-consultation/SKILL.md | 21 +++++++++++++++++++++ design-review/SKILL.md | 21 +++++++++++++++++++++ design-shotgun/SKILL.md | 21 +++++++++++++++++++++ document-release/SKILL.md | 21 +++++++++++++++++++++ investigate/SKILL.md | 24 +++++++++++++++++++++++- land-and-deploy/SKILL.md | 21 +++++++++++++++++++++ learn/SKILL.md | 21 +++++++++++++++++++++ office-hours/SKILL.md | 21 +++++++++++++++++++++ plan-ceo-review/SKILL.md | 21 +++++++++++++++++++++ plan-design-review/SKILL.md | 21 +++++++++++++++++++++ plan-eng-review/SKILL.md | 21 +++++++++++++++++++++ qa-only/SKILL.md | 21 +++++++++++++++++++++ qa/SKILL.md | 21 +++++++++++++++++++++ retro/SKILL.md | 24 +++++++++++++++++++++++- review/SKILL.md | 24 +++++++++++++++++++++++- scripts/resolvers/learnings.ts | 3 ++- scripts/resolvers/preamble.ts | 25 +++++++++++++++++++++++-- setup-browser-cookies/SKILL.md | 21 +++++++++++++++++++++ setup-deploy/SKILL.md | 21 +++++++++++++++++++++ ship/SKILL.md | 24 +++++++++++++++++++++++- test/gen-skill-docs.test.ts | 11 ++++++++++- test/skill-e2e-learnings.test.ts | 5 +++++ 30 files changed, 594 insertions(+), 8 deletions(-) diff --git a/SKILL.md b/SKILL.md index 9849e78fe..1eeeff2fe 100644 --- a/SKILL.md +++ b/SKILL.md @@ -62,6 +62,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -179,6 +182,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md index 7831d0b4a..c831c835f 100644 --- a/autoplan/SKILL.md +++ b/autoplan/SKILL.md @@ -71,6 +71,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -271,6 +274,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/benchmark/SKILL.md b/benchmark/SKILL.md index 929140835..abfa24daa 100644 --- a/benchmark/SKILL.md +++ b/benchmark/SKILL.md @@ -64,6 +64,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -181,6 +184,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/browse/SKILL.md b/browse/SKILL.md index d97d737d3..36fc89898 100644 --- a/browse/SKILL.md +++ b/browse/SKILL.md @@ -64,6 +64,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -181,6 +184,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/canary/SKILL.md b/canary/SKILL.md index a711689df..5e245bae2 100644 --- a/canary/SKILL.md +++ b/canary/SKILL.md @@ -64,6 +64,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -246,6 +249,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/codex/SKILL.md b/codex/SKILL.md index ea3657764..f01bcba29 100644 --- a/codex/SKILL.md +++ b/codex/SKILL.md @@ -65,6 +65,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -265,6 +268,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/connect-chrome/SKILL.md b/connect-chrome/SKILL.md index fe0d14e63..5084c0e01 100644 --- a/connect-chrome/SKILL.md +++ b/connect-chrome/SKILL.md @@ -62,6 +62,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -262,6 +265,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/cso/SKILL.md b/cso/SKILL.md index 77b11979d..f5dbca095 100644 --- a/cso/SKILL.md +++ b/cso/SKILL.md @@ -68,6 +68,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -250,6 +253,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/design-consultation/SKILL.md b/design-consultation/SKILL.md index cc73ec6a2..91325e11f 100644 --- a/design-consultation/SKILL.md +++ b/design-consultation/SKILL.md @@ -69,6 +69,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -269,6 +272,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/design-review/SKILL.md b/design-review/SKILL.md index 2e0b1d177..31519c551 100644 --- a/design-review/SKILL.md +++ b/design-review/SKILL.md @@ -69,6 +69,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -269,6 +272,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/design-shotgun/SKILL.md b/design-shotgun/SKILL.md index 3ebd118e7..a4dbaa889 100644 --- a/design-shotgun/SKILL.md +++ b/design-shotgun/SKILL.md @@ -66,6 +66,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -248,6 +251,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/document-release/SKILL.md b/document-release/SKILL.md index 0fe79991c..c4f840b6c 100644 --- a/document-release/SKILL.md +++ b/document-release/SKILL.md @@ -66,6 +66,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -248,6 +251,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/investigate/SKILL.md b/investigate/SKILL.md index 1dba6b974..bab696b12 100644 --- a/investigate/SKILL.md +++ b/investigate/SKILL.md @@ -80,6 +80,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -262,6 +265,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. @@ -528,7 +549,8 @@ this session, log it for future sessions: ``` **Types:** `pattern` (reusable approach), `pitfall` (what NOT to do), `preference` -(user stated), `architecture` (structural decision), `tool` (library/framework insight). +(user stated), `architecture` (structural decision), `tool` (library/framework insight), +`operational` (project environment/CLI/workflow knowledge). **Sources:** `observed` (you found this in the code), `user-stated` (user told you), `inferred` (AI deduction), `cross-model` (both Claude and Codex agree). diff --git a/land-and-deploy/SKILL.md b/land-and-deploy/SKILL.md index 997684412..7d40518ca 100644 --- a/land-and-deploy/SKILL.md +++ b/land-and-deploy/SKILL.md @@ -63,6 +63,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -263,6 +266,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/learn/SKILL.md b/learn/SKILL.md index 6172e1b79..f23f89ff7 100644 --- a/learn/SKILL.md +++ b/learn/SKILL.md @@ -66,6 +66,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -248,6 +251,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/office-hours/SKILL.md b/office-hours/SKILL.md index b46e9f601..323a63b0e 100644 --- a/office-hours/SKILL.md +++ b/office-hours/SKILL.md @@ -71,6 +71,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -271,6 +274,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/plan-ceo-review/SKILL.md b/plan-ceo-review/SKILL.md index b3ac1b25d..cffd87478 100644 --- a/plan-ceo-review/SKILL.md +++ b/plan-ceo-review/SKILL.md @@ -69,6 +69,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -269,6 +272,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/plan-design-review/SKILL.md b/plan-design-review/SKILL.md index af43a0693..a7479bf92 100644 --- a/plan-design-review/SKILL.md +++ b/plan-design-review/SKILL.md @@ -67,6 +67,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -267,6 +270,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/plan-eng-review/SKILL.md b/plan-eng-review/SKILL.md index badef1f9a..5ecd68716 100644 --- a/plan-eng-review/SKILL.md +++ b/plan-eng-review/SKILL.md @@ -68,6 +68,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -268,6 +271,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/qa-only/SKILL.md b/qa-only/SKILL.md index 659571f90..4a538657c 100644 --- a/qa-only/SKILL.md +++ b/qa-only/SKILL.md @@ -64,6 +64,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -264,6 +267,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/qa/SKILL.md b/qa/SKILL.md index 57dfe86a5..0e03a4c61 100644 --- a/qa/SKILL.md +++ b/qa/SKILL.md @@ -70,6 +70,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -270,6 +273,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/retro/SKILL.md b/retro/SKILL.md index 19b487eef..4d202efa0 100644 --- a/retro/SKILL.md +++ b/retro/SKILL.md @@ -64,6 +64,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -246,6 +249,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. @@ -621,7 +642,8 @@ this session, log it for future sessions: ``` **Types:** `pattern` (reusable approach), `pitfall` (what NOT to do), `preference` -(user stated), `architecture` (structural decision), `tool` (library/framework insight). +(user stated), `architecture` (structural decision), `tool` (library/framework insight), +`operational` (project environment/CLI/workflow knowledge). **Sources:** `observed` (you found this in the code), `user-stated` (user told you), `inferred` (AI deduction), `cross-model` (both Claude and Codex agree). diff --git a/review/SKILL.md b/review/SKILL.md index 538353271..6463e80ec 100644 --- a/review/SKILL.md +++ b/review/SKILL.md @@ -67,6 +67,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -267,6 +270,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. @@ -1190,7 +1211,8 @@ this session, log it for future sessions: ``` **Types:** `pattern` (reusable approach), `pitfall` (what NOT to do), `preference` -(user stated), `architecture` (structural decision), `tool` (library/framework insight). +(user stated), `architecture` (structural decision), `tool` (library/framework insight), +`operational` (project environment/CLI/workflow knowledge). **Sources:** `observed` (you found this in the code), `user-stated` (user told you), `inferred` (AI deduction), `cross-model` (both Claude and Codex agree). diff --git a/scripts/resolvers/learnings.ts b/scripts/resolvers/learnings.ts index 3bcba7b1f..685188fb2 100644 --- a/scripts/resolvers/learnings.ts +++ b/scripts/resolvers/learnings.ts @@ -80,7 +80,8 @@ ${binDir}/gstack-learnings-log '{"skill":"${ctx.skillName}","type":"TYPE","key": \`\`\` **Types:** \`pattern\` (reusable approach), \`pitfall\` (what NOT to do), \`preference\` -(user stated), \`architecture\` (structural decision), \`tool\` (library/framework insight). +(user stated), \`architecture\` (structural decision), \`tool\` (library/framework insight), +\`operational\` (project environment/CLI/workflow knowledge). **Sources:** \`observed\` (you found this in the code), \`user-stated\` (user told you), \`inferred\` (AI deduction), \`cross-model\` (both Claude and Codex agree). diff --git a/scripts/resolvers/preamble.ts b/scripts/resolvers/preamble.ts index 846129259..978bf51c7 100644 --- a/scripts/resolvers/preamble.ts +++ b/scripts/resolvers/preamble.ts @@ -70,6 +70,9 @@ _LEARN_FILE="\${GSTACK_HOME:-$HOME/.gstack}/projects/\${SLUG:-unknown}/learnings if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ${ctx.paths.binDir}/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -322,7 +325,7 @@ jq -n --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" --arg skill "SKILL_NAME" --arg b \`\`\``; } -function generateCompletionStatus(): string { +function generateCompletionStatus(ctx: TemplateContext): string { return `## Completion Status Protocol When completing a skill workflow, report status using one of: @@ -348,6 +351,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] \`\`\` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +\`\`\`bash +${ctx.paths.binDir}/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +\`\`\` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. @@ -502,7 +523,7 @@ export function generatePreamble(ctx: TemplateContext): string { generateVoiceDirective(tier), ...(tier >= 2 ? [generateAskUserFormat(ctx), generateCompletenessSection()] : []), ...(tier >= 3 ? [generateRepoModeSection(), generateSearchBeforeBuildingSection(ctx)] : []), - generateCompletionStatus(), + generateCompletionStatus(ctx), ]; return sections.join('\n\n'); } diff --git a/setup-browser-cookies/SKILL.md b/setup-browser-cookies/SKILL.md index 5c2fe7fe7..ea1a59636 100644 --- a/setup-browser-cookies/SKILL.md +++ b/setup-browser-cookies/SKILL.md @@ -61,6 +61,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -178,6 +181,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/setup-deploy/SKILL.md b/setup-deploy/SKILL.md index 79cff939e..16e4ab6f6 100644 --- a/setup-deploy/SKILL.md +++ b/setup-deploy/SKILL.md @@ -67,6 +67,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -249,6 +252,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. diff --git a/ship/SKILL.md b/ship/SKILL.md index aede6dd57..b801bc792 100644 --- a/ship/SKILL.md +++ b/ship/SKILL.md @@ -65,6 +65,9 @@ _LEARN_FILE="${GSTACK_HOME:-$HOME/.gstack}/projects/${SLUG:-unknown}/learnings.j if [ -f "$_LEARN_FILE" ]; then _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ') echo "LEARNINGS: $_LEARN_COUNT entries loaded" + if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then + ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 3 2>/dev/null || true + fi else echo "LEARNINGS: 0" fi @@ -265,6 +268,24 @@ ATTEMPTED: [what you tried] RECOMMENDATION: [what the user should do next] ``` +## Operational Self-Improvement + +Before completing, reflect on this session: +- Did any commands fail unexpectedly? +- Did you take a wrong approach and have to backtrack? +- Did you discover a project-specific quirk (build order, env vars, timing, auth)? +- Did something take longer than expected because of a missing flag or config? + +If yes, log an operational learning for future sessions: + +```bash +~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}' +``` + +Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. +Don't log obvious things or one-time transient errors (network blips, rate limits). +A good test: would knowing this save 5+ minutes in a future session? If yes, log it. + ## Telemetry (run last) After the skill workflow completes (success, error, or abort), log the telemetry event. @@ -1662,7 +1683,8 @@ this session, log it for future sessions: ``` **Types:** `pattern` (reusable approach), `pitfall` (what NOT to do), `preference` -(user stated), `architecture` (structural decision), `tool` (library/framework insight). +(user stated), `architecture` (structural decision), `tool` (library/framework insight), +`operational` (project environment/CLI/workflow knowledge). **Sources:** `observed` (you found this in the code), `user-stated` (user told you), `inferred` (AI deduction), `cross-model` (both Claude and Codex agree). diff --git a/test/gen-skill-docs.test.ts b/test/gen-skill-docs.test.ts index 29162ab14..9dfac539d 100644 --- a/test/gen-skill-docs.test.ts +++ b/test/gen-skill-docs.test.ts @@ -213,11 +213,20 @@ describe('gen-skill-docs', () => { expect(browseTmpl).toContain('{{PREAMBLE}}'); }); - test('generated SKILL.md contains no contributor mode (removed)', () => { + test('generated SKILL.md contains operational self-improvement (replaced contributor mode)', () => { const content = fs.readFileSync(path.join(ROOT, 'SKILL.md'), 'utf-8'); expect(content).not.toContain('Contributor Mode'); expect(content).not.toContain('gstack_contributor'); expect(content).not.toContain('contributor-logs'); + expect(content).toContain('Operational Self-Improvement'); + expect(content).toContain('gstack-learnings-log'); + expect(content).toContain('gstack-learnings-search --limit 3'); + }); + + test('generated SKILL.md with LEARNINGS_LOG contains operational type', () => { + // Check a skill that has LEARNINGS_LOG (e.g., review) + const content = fs.readFileSync(path.join(ROOT, 'review', 'SKILL.md'), 'utf-8'); + expect(content).toContain('operational'); }); test('generated SKILL.md contains session awareness', () => { diff --git a/test/skill-e2e-learnings.test.ts b/test/skill-e2e-learnings.test.ts index dfd185135..390eedf7f 100644 --- a/test/skill-e2e-learnings.test.ts +++ b/test/skill-e2e-learnings.test.ts @@ -67,6 +67,11 @@ describeIfSelected('Learnings E2E', ['learnings-show'], () => { insight: 'User wants rubocop to run before every commit, no exceptions.', confidence: 10, source: 'user-stated', ts: new Date().toISOString(), }, + { + skill: 'qa', type: 'operational', key: 'test-timeout-flag', + insight: 'bun test requires --timeout 30000 for E2E tests in this project.', + confidence: 9, source: 'observed', ts: new Date().toISOString(), + }, ]; fs.writeFileSync(